dev: add some Must method

Author: zhangxu19830126

format/bytes.go

@@ -3,6 +3,7 @@ package format
 import (
 	"encoding/binary"
 	"fmt"
+	"log"
 )
 
 // Uint16ToBytes uint16 -> bytes
@@ -35,6 +36,15 @@ func BytesToUint16(b []byte) (uint16, error) {
 	return binary.BigEndian.Uint16(b), nil
 }
 
+// MustBytesToUint16 bytes -> uint16
+func MustBytesToUint16(b []byte) uint16 {
+	if len(b) != 2 {
+		log.Fatalf("invalid data, must 2 bytes, but %d", len(b))
+	}
+
+	return binary.BigEndian.Uint16(b)
+}
+
 // BytesToUint32 bytes -> uint32
 func BytesToUint32(b []byte) (uint32, error) {
 	if len(b) != 4 {
@@ -44,6 +54,15 @@ func BytesToUint32(b []byte) (uint32, error) {
 	return binary.BigEndian.Uint32(b), nil
 }
 
+// MustBytesToUint32 bytes -> uint16
+func MustBytesToUint32(b []byte) uint32 {
+	if len(b) != 4 {
+		log.Fatalf("invalid data, must 4 bytes, but %d", len(b))
+	}
+
+	return binary.BigEndian.Uint32(b)
+}
+
 // BytesToUint64 bytes -> uint64
 func BytesToUint64(b []byte) (uint64, error) {
 	if len(b) != 8 {
@@ -52,3 +71,12 @@ func BytesToUint64(b []byte) (uint64, error) {
 
 	return binary.BigEndian.Uint64(b), nil
 }
+
+// MustBytesToUint64 bytes -> uint16
+func MustBytesToUint64(b []byte) uint64 {
+	if len(b) != 8 {
+		log.Fatalf("invalid data, must 8 bytes, but %d", len(b))
+	}
+
+	return binary.BigEndian.Uint64(b)
+}

format/string.go

@@ -1,17 +1,71 @@
 package format
 
 import (
+	"log"
+	"runtime"
 	"strconv"
-
-	"github.com/fagongzi/util/hack"
 )
 
+// ParseStrUInt64 str -> uint64
+func ParseStrUInt64(data string) (uint64, error) {
+	ret, err := strconv.ParseInt(data, 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	return uint64(ret), nil
+}
+
+// MustParseStrUInt64 str -> uint64
+func MustParseStrUInt64(data string) uint64 {
+	value, err := ParseStrUInt64(data)
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("parse to uint64 failed, data=<%s> errors:\n %+v \n %s",
+			data,
+			err,
+			buf)
+	}
+
+	return value
+}
+
 // ParseStrInt64 str -> int64
-func ParseStrInt64(v []byte) (int64, error) {
-	return strconv.ParseInt(hack.SliceToString(v), 10, 64)
+func ParseStrInt64(data string) (int64, error) {
+	return strconv.ParseInt(data, 10, 64)
+}
+
+// MustParseStrInt64 str -> int64
+func MustParseStrInt64(data string) int64 {
+	value, err := ParseStrInt64(data)
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("parse to int64 failed, data=<%s> errors:\n %+v \n %s",
+			data,
+			err,
+			buf)
+	}
+
+	return value
 }
 
 // ParseStrFloat64 str -> float64
-func ParseStrFloat64(v []byte) (float64, error) {
-	return strconv.ParseFloat(hack.SliceToString(v), 64)
+func ParseStrFloat64(data string) (float64, error) {
+	return strconv.ParseFloat(data, 64)
+}
+
+// MustParseStrFloat64 str -> float64
+func MustParseStrFloat64(data string) float64 {
+	value, err := ParseStrFloat64(data)
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("parse to float64 failed, data=<%s> errors:\n %+v \n %s",
+			data,
+			err,
+			buf)
+	}
+
+	return value
 }

json/json.go

@@ -2,7 +2,8 @@ package json
 
 import (
 	"encoding/json"
-	"fmt"
+	"log"
+	"runtime"
 )
 
 // InitModel init model
@@ -14,7 +15,12 @@ type InitModel interface {
 func MustMarshal(value interface{}) []byte {
 	v, err := json.Marshal(value)
 	if err != nil {
-		panic(fmt.Sprintf("marash failed: %+v", err))
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("json marshal failed, value=<%v> errors:\n %+v \n %s",
+			value,
+			err,
+			buf)
 	}
 	return v
 }
@@ -23,7 +29,12 @@ func MustMarshal(value interface{}) []byte {
 func MustUnmarshal(value interface{}, data []byte) {
 	err := Unmarshal(value, data)
 	if err != nil {
-		panic(fmt.Sprintf("unmarash failed: %+v", err))
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("json unmarshal failed, data=<%v> errors:\n %+v \n %s",
+			data,
+			err,
+			buf)
 	}
 
 	if init, ok := value.(InitModel); ok {

protoc/protoc.go

@@ -0,0 +1,69 @@
+// Copyright 2016 DeepFabric, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protoc
+
+import (
+	"log"
+	"runtime"
+)
+
+// PB pb interface
+type PB interface {
+	Marshal() ([]byte, error)
+	MarshalTo(data []byte) (int, error)
+	Unmarshal(data []byte) error
+}
+
+// MustUnmarshal if unmarshal failed, will panic
+func MustUnmarshal(pb PB, data []byte) {
+	err := pb.Unmarshal(data)
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("pb unmarshal failed, data=<%v> errors:\n %+v \n %s",
+			data,
+			err,
+			buf)
+	}
+}
+
+// MustMarshal if marsh failed, will panic
+func MustMarshal(pb PB) []byte {
+	data, err := pb.Marshal()
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("pb marshal failed, pb=<%+v> errors:\n %+v \n %s",
+			pb,
+			err,
+			buf)
+	}
+
+	return data
+}
+
+// MustMarshalTo if marsh failed, will panic
+func MustMarshalTo(pb PB, data []byte) int {
+	n, err := pb.MarshalTo(data)
+	if err != nil {
+		buf := make([]byte, 4096)
+		runtime.Stack(buf, true)
+		log.Fatalf("pb marshal failed, pb=<%v> errors:\n %+v \n %s",
+			pb,
+			err,
+			buf)
+	}
+
+	return n
+}