add vendor

vendor/github.com/siddontang/go/num/bytes.go

@@ -0,0 +1,67 @@
+package num
+
+import (
+	"encoding/binary"
+)
+
+//all are bigendian format
+
+func BytesToUint16(b []byte) uint16 {
+	return binary.BigEndian.Uint16(b)
+}
+
+func Uint16ToBytes(u uint16) []byte {
+	buf := make([]byte, 2)
+	binary.BigEndian.PutUint16(buf, u)
+	return buf
+}
+
+func BytesToUint32(b []byte) uint32 {
+	return binary.BigEndian.Uint32(b)
+}
+
+func Uint32ToBytes(u uint32) []byte {
+	buf := make([]byte, 4)
+	binary.BigEndian.PutUint32(buf, u)
+	return buf
+}
+
+func BytesToUint64(b []byte) uint64 {
+	return binary.BigEndian.Uint64(b)
+}
+
+func Uint64ToBytes(u uint64) []byte {
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, u)
+	return buf
+}
+
+func BytesToInt16(b []byte) int16 {
+	return int16(binary.BigEndian.Uint16(b))
+}
+
+func Int16ToBytes(u int16) []byte {
+	buf := make([]byte, 2)
+	binary.BigEndian.PutUint16(buf, uint16(u))
+	return buf
+}
+
+func BytesToInt32(b []byte) int32 {
+	return int32(binary.BigEndian.Uint32(b))
+}
+
+func Int32ToBytes(u int32) []byte {
+	buf := make([]byte, 4)
+	binary.BigEndian.PutUint32(buf, uint32(u))
+	return buf
+}
+
+func BytesToInt64(b []byte) int64 {
+	return int64(binary.BigEndian.Uint64(b))
+}
+
+func Int64ToBytes(u int64) []byte {
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, uint64(u))
+	return buf
+}

vendor/github.com/siddontang/go/num/cmp.go

@@ -0,0 +1,161 @@
+package num
+
+func MinUint(a uint, b uint) uint {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxUint(a uint, b uint) uint {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinInt(a int, b int) int {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxInt(a int, b int) int {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinUint8(a uint8, b uint8) uint8 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxUint8(a uint8, b uint8) uint8 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinInt8(a int8, b int8) int8 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxInt8(a int8, b int8) int8 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinUint16(a uint16, b uint16) uint16 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxUint16(a uint16, b uint16) uint16 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinInt16(a int16, b int16) int16 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxInt16(a int16, b int16) int16 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinUint32(a uint32, b uint32) uint32 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxUint32(a uint32, b uint32) uint32 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinInt32(a int32, b int32) int32 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxInt32(a int32, b int32) int32 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinUint64(a uint64, b uint64) uint64 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxUint64(a uint64, b uint64) uint64 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}
+
+func MinInt64(a int64, b int64) int64 {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func MaxInt64(a int64, b int64) int64 {
+	if a > b {
+		return a
+	} else {
+		return b
+	}
+}

vendor/github.com/siddontang/go/num/str.go

@@ -0,0 +1,157 @@
+package num
+
+import (
+	"strconv"
+)
+
+func ParseUint(s string) (uint, error) {
+	if v, err := strconv.ParseUint(s, 10, 0); err != nil {
+		return 0, err
+	} else {
+		return uint(v), nil
+	}
+}
+
+func ParseUint8(s string) (uint8, error) {
+	if v, err := strconv.ParseUint(s, 10, 8); err != nil {
+		return 0, err
+	} else {
+		return uint8(v), nil
+	}
+}
+
+func ParseUint16(s string) (uint16, error) {
+	if v, err := strconv.ParseUint(s, 10, 16); err != nil {
+		return 0, err
+	} else {
+		return uint16(v), nil
+	}
+}
+
+func ParseUint32(s string) (uint32, error) {
+	if v, err := strconv.ParseUint(s, 10, 32); err != nil {
+		return 0, err
+	} else {
+		return uint32(v), nil
+	}
+}
+
+func ParseUint64(s string) (uint64, error) {
+	return strconv.ParseUint(s, 10, 64)
+}
+
+func ParseInt(s string) (int, error) {
+	if v, err := strconv.ParseInt(s, 10, 0); err != nil {
+		return 0, err
+	} else {
+		return int(v), nil
+	}
+}
+
+func ParseInt8(s string) (int8, error) {
+	if v, err := strconv.ParseInt(s, 10, 8); err != nil {
+		return 0, err
+	} else {
+		return int8(v), nil
+	}
+}
+
+func ParseInt16(s string) (int16, error) {
+	if v, err := strconv.ParseInt(s, 10, 16); err != nil {
+		return 0, err
+	} else {
+		return int16(v), nil
+	}
+}
+
+func ParseInt32(s string) (int32, error) {
+	if v, err := strconv.ParseInt(s, 10, 32); err != nil {
+		return 0, err
+	} else {
+		return int32(v), nil
+	}
+}
+
+func ParseInt64(s string) (int64, error) {
+	return strconv.ParseInt(s, 10, 64)
+}
+
+func FormatInt(v int) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func FormatInt8(v int8) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func FormatInt16(v int16) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func FormatInt32(v int32) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func FormatInt64(v int64) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func FormatUint(v uint) string {
+	return strconv.FormatUint(uint64(v), 10)
+}
+
+func FormatUint8(v uint8) string {
+	return strconv.FormatUint(uint64(v), 10)
+}
+
+func FormatUint16(v uint16) string {
+	return strconv.FormatUint(uint64(v), 10)
+}
+
+func FormatUint32(v uint32) string {
+	return strconv.FormatUint(uint64(v), 10)
+}
+
+func FormatUint64(v uint64) string {
+	return strconv.FormatUint(uint64(v), 10)
+}
+
+func FormatIntToSlice(v int) []byte {
+	return strconv.AppendInt(nil, int64(v), 10)
+}
+
+func FormatInt8ToSlice(v int8) []byte {
+	return strconv.AppendInt(nil, int64(v), 10)
+}
+
+func FormatInt16ToSlice(v int16) []byte {
+	return strconv.AppendInt(nil, int64(v), 10)
+}
+
+func FormatInt32ToSlice(v int32) []byte {
+	return strconv.AppendInt(nil, int64(v), 10)
+}
+
+func FormatInt64ToSlice(v int64) []byte {
+	return strconv.AppendInt(nil, int64(v), 10)
+}
+
+func FormatUintToSlice(v uint) []byte {
+	return strconv.AppendUint(nil, uint64(v), 10)
+}
+
+func FormatUint8ToSlice(v uint8) []byte {
+	return strconv.AppendUint(nil, uint64(v), 10)
+}
+
+func FormatUint16ToSlice(v uint16) []byte {
+	return strconv.AppendUint(nil, uint64(v), 10)
+}
+
+func FormatUint32ToSlice(v uint32) []byte {
+	return strconv.AppendUint(nil, uint64(v), 10)
+}
+
+func FormatUint64ToSlice(v uint64) []byte {
+	return strconv.AppendUint(nil, uint64(v), 10)
+}