codec: StringToRaw should only be checked in the Handle

Previously, we checked StringToRaw everytime a string is to be encoded.
This helped prevent an unnecessary function call overhead, but also
exploded the size of generated files and users had to explicitly check
each time.

Now, we put it into the Handle, so the function call overhead can be
eliminated at the Handle's encDriver implementation.

README.md

@@ -262,7 +262,7 @@ some caveats. See Encode documentation.
 
 ```go
 const CborStreamBytes byte = 0x5f ...
-const GenVersion = 14
+const GenVersion = 15
 var SelfExt = &extFailWrapper{}
 var GoRpc goRpc
 var MsgpackSpecRpc msgpackSpecRpc

codec/binc.go

@@ -320,17 +320,26 @@ func (e *bincEncDriver) EncodeSymbol(v string) {
 	}
 }
 
+func (e *bincEncDriver) EncodeString(v string) {
+	if e.h.StringToRaw {
+		e.encLen(bincVdByteArray<<4, uint64(len(v))) // e.encBytesLen(c, l)
+		if len(v) > 0 {
+			e.e.encWr.writestr(v)
+		}
+		return
+	}
+	e.EncodeStringEnc(cUTF8, v)
+}
+
 func (e *bincEncDriver) EncodeStringEnc(c charEncoding, v string) {
 	if e.e.c == containerMapKey && c == cUTF8 && (e.h.AsSymbols == 0 || e.h.AsSymbols == 1) {
 		e.EncodeSymbol(v)
 		return
 	}
-	l := uint64(len(v))
-	e.encLen(bincVdString<<4, l) // e.encBytesLen(c, l)
-	if l > 0 {
+	e.encLen(bincVdString<<4, uint64(len(v))) // e.encBytesLen(c, l)
+	if len(v) > 0 {
 		e.e.encWr.writestr(v)
 	}
-
 }
 
 func (e *bincEncDriver) EncodeStringBytesRaw(v []byte) {
@@ -338,9 +347,8 @@ func (e *bincEncDriver) EncodeStringBytesRaw(v []byte) {
 		e.EncodeNil()
 		return
 	}
-	l := uint64(len(v))
-	e.encLen(bincVdByteArray<<4, l) // e.encBytesLen(c, l)
-	if l > 0 {
+	e.encLen(bincVdByteArray<<4, uint64(len(v))) // e.encBytesLen(c, l)
+	if len(v) > 0 {
 		e.e.encWr.writeb(v)
 	}
 }

codec/cbor.go

@@ -185,7 +185,7 @@ func (e *cborEncDriver) EncodeTime(t time.Time) {
 		e.EncodeNil()
 	} else if e.h.TimeRFC3339 {
 		e.encUint(0, cborBaseTag)
-		e.EncodeStringEnc(cUTF8, t.Format(time.RFC3339Nano))
+		e.encStringBytesS(cborBaseString, t.Format(time.RFC3339Nano))
 	} else {
 		e.encUint(1, cborBaseTag)
 		t = t.UTC().Round(time.Microsecond)
@@ -251,7 +251,11 @@ func (e *cborEncDriver) WriteArrayEnd() {
 	}
 }
 
-func (e *cborEncDriver) EncodeStringEnc(c charEncoding, v string) {
+func (e *cborEncDriver) EncodeString(v string) {
+	if e.h.StringToRaw {
+		e.EncodeStringBytesRaw(bytesView(v))
+		return
+	}
 	e.encStringBytesS(cborBaseString, v)
 }
 

codec/encode.go

@@ -31,7 +31,9 @@ type encDriver interface {
 	// encodeExtPreamble(xtag byte, length int)
 	EncodeRawExt(re *RawExt)
 	EncodeExt(v interface{}, xtag uint64, ext Ext)
-	EncodeStringEnc(c charEncoding, v string) // c cannot be cRAW
+	// EncodeString using cUTF8, honor'ing StringToRaw flag
+	EncodeString(v string)
+	// EncodeStringEnc(c charEncoding, v string) // c cannot be cRAW
 	// EncodeSymbol(v string)
 	EncodeStringBytesRaw(v []byte)
 	EncodeTime(time.Time)
@@ -217,11 +219,12 @@ func (e *Encoder) kTime(f *codecFnInfo, rv reflect.Value) {
 }
 
 func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
-	if e.h.StringToRaw {
-		e.e.EncodeStringBytesRaw(bytesView(rvGetString(rv)))
-	} else {
-		e.e.EncodeStringEnc(cUTF8, rvGetString(rv))
-	}
+	e.e.EncodeString(rvGetString(rv))
+	// if e.h.StringToRaw {
+	// 	e.e.EncodeStringBytesRaw(bytesView(rvGetString(rv)))
+	// } else {
+	// 	e.e.EncodeStringEnc(cUTF8, rvGetString(rv))
+	// }
 }
 
 // func (e *Encoder) kString(f *codecFnInfo, rv reflect.Value) {
@@ -676,11 +679,12 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 			vx = rvk
 		}
 		if keyTypeIsString {
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(vx.String()))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, vx.String())
-			}
+			e.e.EncodeString(vx.String())
+			// if e.h.StringToRaw {
+			// 	e.e.EncodeStringBytesRaw(bytesView(vx.String()))
+			// } else {
+			// 	e.e.EncodeStringEnc(cUTF8, vx.String())
+			// }
 		} else {
 			e.encodeValue(vx, keyFn)
 		}
@@ -727,11 +731,12 @@ func (e *Encoder) kMapCanonical(rtkey, rtval reflect.Type, rv, rvv reflect.Value
 		sort.Sort(stringRvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(mksv[i].v))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, mksv[i].v)
-			}
+			e.e.EncodeString(mksv[i].v)
+			// if e.h.StringToRaw {
+			// 	e.e.EncodeStringBytesRaw(bytesView(mksv[i].v))
+			// } else {
+			// 	e.e.EncodeStringEnc(cUTF8, mksv[i].v)
+			// }
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv), valFn) // e.encodeValue(rv.MapIndex(mksv[i].r), valFn)
 		}
@@ -1192,11 +1197,12 @@ func (e *Encoder) encode(iv interface{}) {
 		e.encodeValue(v, nil)
 
 	case string:
-		if e.h.StringToRaw {
-			e.e.EncodeStringBytesRaw(bytesView(v))
-		} else {
-			e.e.EncodeStringEnc(cUTF8, v)
-		}
+		e.e.EncodeString(v)
+		// if e.h.StringToRaw {
+		// 	e.e.EncodeStringBytesRaw(bytesView(v))
+		// } else {
+		// 	e.e.EncodeStringEnc(cUTF8, v)
+		// }
 	case bool:
 		e.e.EncodeBool(v)
 	case int:
@@ -1232,11 +1238,12 @@ func (e *Encoder) encode(iv interface{}) {
 	case *Raw:
 		e.rawBytes(*v)
 	case *string:
-		if e.h.StringToRaw {
-			e.e.EncodeStringBytesRaw(bytesView(*v))
-		} else {
-			e.e.EncodeStringEnc(cUTF8, *v)
-		}
+		e.e.EncodeString(*v)
+		// if e.h.StringToRaw {
+		// 	e.e.EncodeStringBytesRaw(bytesView(*v))
+		// } else {
+		// 	e.e.EncodeStringEnc(cUTF8, *v)
+		// }
 	case *bool:
 		e.e.EncodeBool(*v)
 	case *int:
@@ -1379,7 +1386,8 @@ func (e *Encoder) marshalUtf8(bs []byte, fnerr error) {
 	if bs == nil {
 		e.e.EncodeNil()
 	} else {
-		e.e.EncodeStringEnc(cUTF8, stringView(bs))
+		e.e.EncodeString(stringView(bs))
+		// e.e.EncodeStringEnc(cUTF8, stringView(bs))
 	}
 }
 
@@ -1519,7 +1527,7 @@ func encStructFieldKey(encName string, ee encDriver, w *encWr,
 			// b[len(b)-1] = '"'
 			// w.writeb(b)
 		} else { // keyType == valueTypeString
-			ee.EncodeStringEnc(cUTF8, encName)
+			ee.EncodeString(encName)
 		}
 	} else if keyType == valueTypeInt {
 		ee.EncodeInt(m.Int(strconv.ParseInt(encName, 10, 64)))

codec/fast-path.generated.go

@@ -884,11 +884,7 @@ func (fastpathT) EncSliceStringV(v []string, e *Encoder) {
 	e.arrayStart(len(v))
 	for j := range v {
 		e.arrayElem()
-		if e.h.StringToRaw {
-			e.e.EncodeStringBytesRaw(bytesView(v[j]))
-		} else {
-			e.e.EncodeStringEnc(cUTF8, v[j])
-		}
+		e.e.EncodeString(v[j])
 	}
 	e.arrayEnd()
 }
@@ -903,11 +899,7 @@ func (fastpathT) EncAsMapSliceStringV(v []string, e *Encoder) {
 			} else {
 				e.mapElemValue()
 			}
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[j]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[j])
-			}
+			e.e.EncodeString(v[j])
 		}
 		e.mapEnd()
 	}
@@ -1330,22 +1322,14 @@ func (fastpathT) EncMapStringIntfV(v map[string]interface{}, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.encode(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.encode(v2)
 		}
@@ -1367,32 +1351,16 @@ func (fastpathT) EncMapStringStringV(v map[string]string, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[k2]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[k2])
-			}
+			e.e.EncodeString(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()
@@ -1412,22 +1380,14 @@ func (fastpathT) EncMapStringBytesV(v map[string][]byte, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeStringBytesRaw(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeStringBytesRaw(v2)
 		}
@@ -1449,22 +1409,14 @@ func (fastpathT) EncMapStringUintV(v map[string]uint, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(uint64(v[k2]))
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(uint64(v2))
 		}
@@ -1486,22 +1438,14 @@ func (fastpathT) EncMapStringUint8V(v map[string]uint8, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(uint64(v[k2]))
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(uint64(v2))
 		}
@@ -1523,22 +1467,14 @@ func (fastpathT) EncMapStringUint64V(v map[string]uint64, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeUint(v2)
 		}
@@ -1560,22 +1496,14 @@ func (fastpathT) EncMapStringIntV(v map[string]int, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeInt(int64(v[k2]))
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeInt(int64(v2))
 		}
@@ -1597,22 +1525,14 @@ func (fastpathT) EncMapStringInt64V(v map[string]int64, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeInt(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeInt(v2)
 		}
@@ -1634,22 +1554,14 @@ func (fastpathT) EncMapStringFloat32V(v map[string]float32, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeFloat32(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeFloat32(v2)
 		}
@@ -1671,22 +1583,14 @@ func (fastpathT) EncMapStringFloat64V(v map[string]float64, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeFloat64(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeFloat64(v2)
 		}
@@ -1708,22 +1612,14 @@ func (fastpathT) EncMapStringBoolV(v map[string]bool, e *Encoder) {
 		sort.Sort(stringSlice(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeBool(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(k2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, k2)
-			}
+			e.e.EncodeString(k2)
 			e.mapElemValue()
 			e.e.EncodeBool(v2)
 		}
@@ -1776,22 +1672,14 @@ func (fastpathT) EncMapUintStringV(v map[uint]string, e *Encoder) {
 			e.mapElemKey()
 			e.e.EncodeUint(uint64(uint(k2)))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[uint(k2)]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[uint(k2)])
-			}
+			e.e.EncodeString(v[uint(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
 			e.e.EncodeUint(uint64(k2))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()
@@ -2103,22 +1991,14 @@ func (fastpathT) EncMapUint8StringV(v map[uint8]string, e *Encoder) {
 			e.mapElemKey()
 			e.e.EncodeUint(uint64(uint8(k2)))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[uint8(k2)]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[uint8(k2)])
-			}
+			e.e.EncodeString(v[uint8(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
 			e.e.EncodeUint(uint64(k2))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()
@@ -2430,22 +2310,14 @@ func (fastpathT) EncMapUint64StringV(v map[uint64]string, e *Encoder) {
 			e.mapElemKey()
 			e.e.EncodeUint(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[k2]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[k2])
-			}
+			e.e.EncodeString(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
 			e.e.EncodeUint(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()
@@ -2757,22 +2629,14 @@ func (fastpathT) EncMapIntStringV(v map[int]string, e *Encoder) {
 			e.mapElemKey()
 			e.e.EncodeInt(int64(int(k2)))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[int(k2)]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[int(k2)])
-			}
+			e.e.EncodeString(v[int(k2)])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
 			e.e.EncodeInt(int64(k2))
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()
@@ -3084,22 +2948,14 @@ func (fastpathT) EncMapInt64StringV(v map[int64]string, e *Encoder) {
 			e.mapElemKey()
 			e.e.EncodeInt(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v[k2]))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v[k2])
-			}
+			e.e.EncodeString(v[k2])
 		}
 	} else {
 		for k2, v2 := range v {
 			e.mapElemKey()
 			e.e.EncodeInt(k2)
 			e.mapElemValue()
-			if e.h.StringToRaw {
-				e.e.EncodeStringBytesRaw(bytesView(v2))
-			} else {
-				e.e.EncodeStringEnc(cUTF8, v2)
-			}
+			e.e.EncodeString(v2)
 		}
 	}
 	e.mapEnd()

codec/fast-path.go.tmpl

@@ -235,14 +235,14 @@ func (fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem
 		sort.Sort({{ sorttype .MapKey false}}(v2))
 		for _, k2 := range v2 {
 			e.mapElemKey()
-			{{if eq .MapKey "string"}} if e.h.StringToRaw {e.e.EncodeStringBytesRaw(bytesView(k2))} else {e.e.EncodeStringEnc(cUTF8, k2)} {{else}}{{ $y := printf "%s(k2)" .MapKey }}{{if eq $x .MapKey }}{{ $y = "k2" }}{{end}}{{ encmd .MapKey $y }}{{end}}
+			{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ $y := printf "%s(k2)" .MapKey }}{{if eq $x .MapKey }}{{ $y = "k2" }}{{end}}{{ encmd .MapKey $y }}{{end}}
 			e.mapElemValue()
 			{{ $y := printf "v[%s(k2)]" .MapKey }}{{if eq $x .MapKey }}{{ $y = "v[k2]" }}{{end}}{{ encmd .Elem $y }}
 		} {{end}}
 	} else { 
 		for k2, v2 := range v {
 			e.mapElemKey()
-			{{if eq .MapKey "string"}} if e.h.StringToRaw {e.e.EncodeStringBytesRaw(bytesView(k2))} else {e.e.EncodeStringEnc(cUTF8, k2)} {{else}}{{ encmd .MapKey "k2"}}{{end}}
+			{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ encmd .MapKey "k2"}}{{end}}
 			e.mapElemValue()
 			{{ encmd .Elem "v2"}}
 		}

codec/gen-helper.generated.go

@@ -10,7 +10,7 @@ package codec
 import "encoding"
 
 // GenVersion is the current version of codecgen.
-const GenVersion = 14
+const GenVersion = 15
 
 // This file is used to generate helper code for codecgen.
 // The values here i.e. genHelper(En|De)coder are not to be used directly by

codec/gen.go

@@ -110,7 +110,8 @@ import (
 // v12: removed deprecated methods from genHelper and changed container tracking logic
 // v13: 20190603 removed DecodeString - use DecodeStringAsBytes instead
 // v14: 20190611 refactored nil handling: TryDecodeAsNil -> selective TryNil, etc
-const genVersion = 14
+// v15: 20190626 encDriver.EncodeString handles StringToRaw flag inside handle
+const genVersion = 15
 
 const (
 	genCodecPkg        = "codec1978"
@@ -888,7 +889,7 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(bool(" + varname + "))")
 	case reflect.String:
-		x.linef("if z.EncBasicHandle().StringToRaw { r.EncodeStringBytesRaw(z.BytesView(string(%s))) } else { r.EncodeStringEnc(codecSelferCcUTF8%s, string(%s)) }", varname, x.xs, varname)
+		x.linef("r.EncodeString(string(%s))", varname)
 	case reflect.Chan:
 		x.xtraSM(varname, t, true, false)
 		// x.encListFallback(varname, rtid, t)
@@ -955,7 +956,7 @@ func (x *genRunner) encZero(t reflect.Type) {
 	case reflect.Bool:
 		x.line("r.EncodeBool(false)")
 	case reflect.String:
-		x.linef(`if z.EncBasicHandle().StringToRaw { r.EncodeStringBytesRaw([]byte{}) } else { r.EncodeStringEnc(codecSelferCcUTF8%s, "") }`, x.xs)
+		x.linef(`r.EncodeString("")`)
 	default:
 		x.line("r.EncodeNil()")
 	}
@@ -1183,7 +1184,7 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 			if si.encNameAsciiAlphaNum {
 				x.linef(`if z.IsJSONHandle() { z.WriteStr("\"%s\"") } else { `, si.encName)
 			}
-			x.linef("r.EncodeStringEnc(codecSelferCcUTF8%s, `%s`)", x.xs, si.encName)
+			x.linef("r.EncodeString(`%s`)", si.encName)
 			if si.encNameAsciiAlphaNum {
 				x.linef("}")
 			}
@@ -2118,8 +2119,7 @@ func genInternalEncCommandAsString(s string, vname string) string {
 	case "[]byte", "[]uint8", "bytes":
 		return "e.e.EncodeStringBytesRaw(" + vname + ")"
 	case "string":
-		return "if e.h.StringToRaw { e.e.EncodeStringBytesRaw(bytesView(" + vname + ")) " +
-			"} else { e.e.EncodeStringEnc(cUTF8, " + vname + ") }"
+		return "e.e.EncodeString(" + vname + ")"
 	case "float32":
 		return "e.e.EncodeFloat32(" + vname + ")"
 	case "float64":

codec/json.go

@@ -328,7 +328,11 @@ func (e *jsonEncDriver) EncodeUint(v uint64) {
 // 	e.EncodeFloat64(float64(f))
 // }
 
-func (e *jsonEncDriver) EncodeStringEnc(c charEncoding, v string) {
+func (e *jsonEncDriver) EncodeString(v string) {
+	if e.h.StringToRaw {
+		e.EncodeStringBytesRaw(bytesView(v))
+		return
+	}
 	e.quoteStr(v)
 }
 

codec/msgpack.go

@@ -382,14 +382,32 @@ func (e *msgpackEncDriver) WriteMapStart(length int) {
 	e.writeContainerLen(msgpackContainerMap, length)
 }
 
-func (e *msgpackEncDriver) EncodeStringEnc(c charEncoding, s string) {
-	slen := len(s)
+func (e *msgpackEncDriver) EncodeString(s string) {
+	var ct msgpackContainerType
 	if e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerStr, slen)
+		if e.h.StringToRaw {
+			ct = msgpackContainerBin
+		} else {
+			ct = msgpackContainerStr
+		}
 	} else {
-		e.writeContainerLen(msgpackContainerRawLegacy, slen)
+		ct = msgpackContainerRawLegacy
 	}
-	if slen > 0 {
+	// if e.h.StringToRaw {
+	// 	if e.h.WriteExt {
+	// 		ct = msgpackContainerBin
+	// 	} else {
+	// 		ct = msgpackContainerRawLegacy
+	// 	}
+	// } else {
+	// 	if e.h.WriteExt {
+	// 		ct = msgpackContainerStr
+	// 	} else {
+	// 		ct = msgpackContainerRawLegacy
+	// 	}
+	// }
+	e.writeContainerLen(ct, len(s))
+	if len(s) > 0 {
 		e.e.encWr.writestr(s)
 	}
 }
@@ -399,13 +417,12 @@ func (e *msgpackEncDriver) EncodeStringBytesRaw(bs []byte) {
 		e.EncodeNil()
 		return
 	}
-	slen := len(bs)
 	if e.h.WriteExt {
-		e.writeContainerLen(msgpackContainerBin, slen)
+		e.writeContainerLen(msgpackContainerBin, len(bs))
 	} else {
-		e.writeContainerLen(msgpackContainerRawLegacy, slen)
+		e.writeContainerLen(msgpackContainerRawLegacy, len(bs))
 	}
-	if slen > 0 {
+	if len(bs) > 0 {
 		e.e.encWr.writeb(bs)
 	}
 }

codec/simple.go

@@ -170,12 +170,16 @@ func (e *simpleEncDriver) WriteMapStart(length int) {
 // 	e.EncodeStringEnc(cUTF8, v)
 // }
 
-func (e *simpleEncDriver) EncodeStringEnc(c charEncoding, v string) {
+func (e *simpleEncDriver) EncodeString(v string) {
 	if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == "" {
 		e.EncodeNil()
 		return
 	}
-	e.encLen(simpleVdString, len(v))
+	if e.h.StringToRaw {
+		e.encLen(simpleVdByteArray, len(v))
+	} else {
+		e.encLen(simpleVdString, len(v))
+	}
 	e.e.encWr.writestr(v)
 }