更新

Author: deatil

encoding/base45.go

@@ -6,18 +6,17 @@ import (
 
 // Base45
 func (this Encoding) Base45Decode() Encoding {
-    data := string(this.data)
-    decoded, err := base45.Decode(data)
+    decoded, err := base45.StdEncoding.DecodeString(string(this.data))
 
-    this.data = []byte(decoded)
+    this.data = decoded
     this.Error = err
 
     return this
 }
 
 // 编码 Base45
 func (this Encoding) Base45Encode() Encoding {
-    data := base45.Encode(string(this.data))
+    data := base45.StdEncoding.EncodeToString(this.data)
     this.data = []byte(data)
 
     return this

encoding/basex.go

@@ -7,14 +7,14 @@ import (
 // Basex2
 func (this Encoding) Basex2Decode() Encoding {
     data := string(this.data)
-    this.data, this.Error = basex.Base2Encoding.Decode(data)
+    this.data, this.Error = basex.Base2Encoding.DecodeString(data)
 
     return this
 }
 
 // 编码 Base2
 func (this Encoding) Basex2Encode() Encoding {
-    data := basex.Base2Encoding.Encode(this.data)
+    data := basex.Base2Encoding.EncodeToString(this.data)
     this.data = []byte(data)
 
     return this
@@ -25,14 +25,14 @@ func (this Encoding) Basex2Encode() Encoding {
 // Basex16
 func (this Encoding) Basex16Decode() Encoding {
     data := string(this.data)
-    this.data, this.Error = basex.Base16Encoding.Decode(data)
+    this.data, this.Error = basex.Base16Encoding.DecodeString(data)
 
     return this
 }
 
 // 编码 Base16
 func (this Encoding) Basex16Encode() Encoding {
-    data := basex.Base16Encoding.Encode(this.data)
+    data := basex.Base16Encoding.EncodeToString(this.data)
     this.data = []byte(data)
 
     return this
@@ -43,14 +43,14 @@ func (this Encoding) Basex16Encode() Encoding {
 // Basex62
 func (this Encoding) Basex62Decode() Encoding {
     data := string(this.data)
-    this.data, this.Error = basex.Base62Encoding.Decode(data)
+    this.data, this.Error = basex.Base62Encoding.DecodeString(data)
 
     return this
 }
 
 // 编码 Basex62
 func (this Encoding) Basex62Encode() Encoding {
-    data := basex.Base62Encoding.Encode(this.data)
+    data := basex.Base62Encoding.EncodeToString(this.data)
     this.data = []byte(data)
 
     return this
@@ -61,14 +61,14 @@ func (this Encoding) Basex62Encode() Encoding {
 // BasexDecodeWithEncoder
 func (this Encoding) BasexDecodeWithEncoder(encoder string) Encoding {
     data := string(this.data)
-    this.data, this.Error = basex.NewEncoding(encoder).Decode(data)
+    this.data, this.Error = basex.NewEncoding(encoder).DecodeString(data)
 
     return this
 }
 
 // BasexEncodeWithEncoder
 func (this Encoding) BasexEncodeWithEncoder(encoder string) Encoding {
-    data := basex.NewEncoding(encoder).Encode(this.data)
+    data := basex.NewEncoding(encoder).EncodeToString(this.data)
     this.data = []byte(data)
 
     return this

encoding/morse.go

@@ -6,18 +6,17 @@ import (
 
 // MorseITU
 func (this Encoding) MorseITUDecode() Encoding {
-    data := string(this.data)
-    data, err := morse.DecodeITU(data)
+    data, err := morse.ITUEncoding.DecodeString(string(this.data))
 
-    this.data = []byte(data)
+    this.data = data
     this.Error = err
 
     return this
 }
 
 // 编码 MorseITU
 func (this Encoding) MorseITUEncode() Encoding {
-    data := morse.EncodeITU(string(this.data))
+    data := morse.ITUEncoding.EncodeToString(this.data)
     this.data = []byte(data)
 
     return this

morse/morse.go

@@ -2,6 +2,8 @@ package morse
 
 import (
     "fmt"
+    "unsafe"
+    "reflect"
     "strings"
 )
 
@@ -26,9 +28,9 @@ func NewEncoding(alphabet map[string]string, letterSeparator, wordSeparator stri
 }
 
 // Encode encodes clear text in `s` using `alphabet` mapping
-func (enc *Encoding) Encode(s string) string {
+func (enc *Encoding) Encode(s []byte) []byte {
     res := ""
-    for _, part := range s {
+    for _, part := range string(s) {
         p := string(part)
         if p == " " {
             if enc.wordSeparator != "" {
@@ -39,13 +41,19 @@ func (enc *Encoding) Encode(s string) string {
         }
     }
 
-    return strings.TrimSpace(res)
+    return []byte(strings.TrimSpace(res))
+}
+
+// EncodeToString returns the base62 encoding of src.
+func (enc *Encoding) EncodeToString(src []byte) string {
+    buf := enc.Encode(src)
+    return string(buf)
 }
 
 // Decode decodes morse code in `s` using `alphabet` mapping
-func (enc *Encoding) Decode(s string) (string, error) {
+func (enc *Encoding) Decode(s []byte) ([]byte, error) {
     res := ""
-    for _, part := range strings.Split(s, enc.letterSeparator) {
+    for _, part := range strings.Split(string(s), enc.letterSeparator) {
         found := false
         for key, val := range enc.alphabet {
             if val == part {
@@ -61,11 +69,18 @@ func (enc *Encoding) Decode(s string) (string, error) {
         }
 
         if !found {
-            return res, fmt.Errorf("go-encoding/morse: unknown character " + part)
+            return []byte(res), fmt.Errorf("go-encoding/morse: unknown character " + part)
         }
     }
 
-    return res, nil
+    return []byte(res), nil
+}
+
+// DecodeString returns the bytes represented by the base62 string s.
+func (enc *Encoding) DecodeString(s string) ([]byte, error) {
+    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
+    bh := reflect.SliceHeader{Data: sh.Data, Len: sh.Len, Cap: sh.Len}
+    return enc.Decode(*(*[]byte)(unsafe.Pointer(&bh)))
 }
 
 // LooksLikeMorse returns true if string seems to be a morse encoded string

morse/morse_test.go

@@ -2,21 +2,41 @@ package morse
 
 import "testing"
 
-func TestLooksLikeMorse(t *testing.T) {
+func Test_LooksLikeMorse(t *testing.T) {
     if !LooksLikeMorse("- .... . .-..") {
         t.Error("fail 1")
     }
+
     if LooksLikeMorse("one one one...") {
         t.Error("fail 2")
     }
+
     if LooksLikeMorse("") {
         t.Error("fail 3")
     }
 }
 
-func TestDecodeBrokenITU(t *testing.T) {
-    _, err := ITUEncoding.Decode("-- ?.. ...")
+func Test_DecodeBrokenITU(t *testing.T) {
+    _, err := ITUEncoding.DecodeString("-- ?.. ...")
     if err == nil {
         t.Error("expected error")
     }
 }
+
+func Test_EncodeToString(t *testing.T) {
+    in := []byte("test:date")
+
+    encoded := ITUEncoding.EncodeToString(in)
+    if len(encoded) == 0 {
+        t.Error("EncodeToString fail")
+    }
+
+    decoded, err := ITUEncoding.DecodeString(encoded)
+    if err != nil {
+        t.Error("DecodeString fail")
+    }
+
+    if string(decoded) != string(in) {
+        t.Errorf("DecodeString, got %s, want %s", string(decoded), string(in))
+    }
+}