feat(golang): meta string encoding algorithm in golang

go/fury/meta/meta_string.go

@@ -0,0 +1,56 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package meta
+
+// Encoding Algorithms Flags
+type Encoding uint8
+
+const (
+	UTF_8                     Encoding = 0x00
+	LOWER_SPECIAL             Encoding = 0x01
+	LOWER_UPPER_DIGIT_SPECIAL Encoding = 0x02
+	FIRST_TO_LOWER_SPECIAL    Encoding = 0x03
+	ALL_TO_LOWER_SPECIAL      Encoding = 0x04
+)
+
+// MetaString saves the serialized data
+type MetaString struct {
+	inputString  string
+	encoding     Encoding // encoding flag
+	specialChar1 byte
+	specialChar2 byte
+	encodedBytes []byte // serialized data
+}
+
+func (ms *MetaString) GetInputString() string { return ms.inputString }
+
+func (ms *MetaString) GetEncoding() Encoding { return ms.encoding }
+
+func (ms *MetaString) GetSpecialChar1() byte { return ms.specialChar1 }
+
+func (ms *MetaString) GetSpecialChar2() byte { return ms.specialChar2 }
+
+func (ms *MetaString) GetEncodedBytes() []byte { return ms.encodedBytes }
+
+// StripLastChar return true if last char should be stripped
+func (ms *MetaString) StripLastChar() bool {
+	if ms.encoding == UTF_8 || ms.encodedBytes == nil {
+		return false
+	}
+	return (ms.encodedBytes[0] & 0x80) > 0
+}

go/fury/meta/meta_string_decoder.go

@@ -0,0 +1,169 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package meta
+
+import (
+	"fmt"
+)
+
+type Decoder struct {
+	specialChar1 byte
+	specialChar2 byte
+}
+
+func NewDecoder(specialCh1 byte, specialCh2 byte) *Decoder {
+	return &Decoder{
+		specialChar1: specialCh1,
+		specialChar2: specialCh2,
+	}
+}
+
+// Decode
+// Accept an encodedBytes byte array, and the encoding method
+func (d *Decoder) Decode(data []byte, encoding Encoding) (result string, err error) {
+	// we prepend one bit at the start to indicate whether strip last char
+	// so checking empty here will be convenient for decoding procedure
+	if data == nil {
+		return "", err
+	}
+	var chars []byte
+	switch encoding {
+	case LOWER_SPECIAL:
+		chars, err = d.decodeGeneric(data, encoding)
+	case LOWER_UPPER_DIGIT_SPECIAL:
+		chars, err = d.decodeGeneric(data, encoding)
+	case FIRST_TO_LOWER_SPECIAL:
+		chars, err = d.decodeGeneric(data, LOWER_SPECIAL)
+		if err == nil {
+			chars[0] = chars[0] - 'a' + 'A'
+		}
+	case ALL_TO_LOWER_SPECIAL:
+		chars, err = d.decodeRepAllToLowerSpecial(data, LOWER_SPECIAL)
+	case UTF_8:
+		chars = data
+	default:
+		err = fmt.Errorf("Unexpected encoding flag: %v\n", encoding)
+	}
+	if err != nil {
+		return "", err
+	}
+	return string(chars), err
+}
+
+// DecodeGeneric
+// algorithm is LowerSpecial or LowerUpperDigit
+func (d *Decoder) decodeGeneric(data []byte, algorithm Encoding) ([]byte, error) {
+	bitsPerChar := 5
+	if algorithm == LOWER_UPPER_DIGIT_SPECIAL {
+		bitsPerChar = 6
+	}
+	// Retrieve 5 bits every iteration from data, convert them to characters, and save them to chars
+	// "abc" encodedBytes as [00000] [000,01] [00010] [0, corresponding to three bytes, which are 0, 68, 0
+	// Take the highest digit first, then the lower, in order
+
+	// here access data[0] before entering the loop, so we had to deal with empty data in Decode method
+	// totChars * bitsPerChar <= totBits < (totChars + 1) * bitsPerChar
+	stripLastChar := (data[0] & 0x80) >> 7
+	totBits := len(data)*8 - 1 - int(stripLastChar)*bitsPerChar
+	totChars := totBits / bitsPerChar
+	chars := make([]byte, totChars)
+	bitPos, bitCount := 6, 1 // first highest bit indicates whether strip last char
+	for i := 0; i < totChars; i++ {
+		var val byte = 0
+		for i := 0; i < bitsPerChar; i++ {
+			if data[bitCount/8]&(1<<bitPos) > 0 {
+				val |= 1 << (bitsPerChar - i - 1)
+			}
+			bitPos = (bitPos - 1 + 8) % 8
+			bitCount++
+		}
+		ch, err := d.decodeChar(val, algorithm)
+		if err != nil {
+			return nil, err
+		}
+		chars[i] = ch
+	}
+	return chars, nil
+}
+
+func (d *Decoder) decodeRepAllToLowerSpecial(data []byte, algorithm Encoding) ([]byte, error) {
+	// Decode the data to the lowercase letters, then convert
+	str, err := d.decodeGeneric(data, algorithm)
+	if err != nil {
+		return nil, err
+	}
+	chars := make([]byte, len(str))
+	j := 0
+	for i := 0; i < len(str); i++ {
+		if str[i] == '|' {
+			chars[j] = str[i+1] - 'a' + 'A'
+			i++
+		} else {
+			chars[j] = str[i]
+		}
+		j++
+	}
+	return chars[0:j], nil
+}
+
+/** Decoding char for two encoding algorithms */
+func (d *Decoder) decodeChar(val byte, encoding Encoding) (byte, error) {
+	switch encoding {
+	case LOWER_SPECIAL:
+		return d.decodeLowerSpecialChar(val)
+	case LOWER_UPPER_DIGIT_SPECIAL:
+		return d.decodeLowerUpperDigitSpecialChar(val)
+	}
+	return 0, fmt.Errorf("Illegal encoding flag: %v\n", encoding)
+}
+
+/** Decoding char for LOWER_SPECIAL Encoding Algorithm */
+func (d *Decoder) decodeLowerSpecialChar(charValue byte) (val byte, err error) {
+	if charValue <= 25 {
+		val = 'a' + charValue
+	} else if charValue == 26 {
+		val = '.'
+	} else if charValue == 27 {
+		val = '_'
+	} else if charValue == 28 {
+		val = '$'
+	} else if charValue == 29 {
+		val = '|'
+	} else {
+		err = fmt.Errorf("Invalid character value for LOWER_SPECIAL: %v\n", charValue)
+	}
+	return
+}
+
+/** Decoding char for LOWER_UPPER_DIGIT_SPECIAL Encoding Algorithm. */
+func (d *Decoder) decodeLowerUpperDigitSpecialChar(charValue byte) (val byte, err error) {
+	if charValue <= 25 {
+		val = 'a' + charValue
+	} else if charValue >= 26 && charValue <= 51 {
+		val = 'A' + (charValue - 26)
+	} else if charValue >= 52 && charValue <= 61 {
+		val = '0' + (charValue - 52)
+	} else if charValue == 62 {
+		val = d.specialChar1
+	} else if charValue == 63 {
+		val = d.specialChar2
+	} else {
+		err = fmt.Errorf("invalid character value for LOWER_UPPER_DIGIT_SPECIAL: %v", charValue)
+	}
+	return
+}