move lib/go/gremlin to ent/dialect (#1192)

Summary:
Pull Request resolved: https://github.com/facebookexternal/fbc/pull/1192

Pull Request resolved: https://github.com/facebookincubator/ent/pull/11

Reviewed By: alexsn

Differential Revision: D16377224

fbshipit-source-id: 07ca7436eb9b64fbe2299568560b91466b2417ba

dialect/gremlin/encoding/graphson/native.go

@@ -0,0 +1,133 @@
+package graphson
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"unsafe"
+
+	"github.com/json-iterator/go"
+	"github.com/modern-go/reflect2"
+)
+
+// EncoderOfNative returns a value encoder of a native type.
+func (encodeExtension) EncoderOfNative(typ reflect2.Type) jsoniter.ValEncoder {
+	switch typ.Kind() {
+	case reflect.Float64:
+		return float64Encoder{typ}
+	default:
+		return nil
+	}
+}
+
+// DecoratorOfNative decorates a value encoder of a native type.
+func (encodeExtension) DecoratorOfNative(typ reflect2.Type, enc jsoniter.ValEncoder) jsoniter.ValEncoder {
+	switch typ.Kind() {
+	case reflect.Bool, reflect.String:
+		return enc
+	case reflect.Int64, reflect.Int, reflect.Uint32:
+		return typeEncoder{enc, int64Type}
+	case reflect.Int32, reflect.Int8, reflect.Uint16:
+		return typeEncoder{enc, int32Type}
+	case reflect.Int16:
+		return typeEncoder{enc, int16Type}
+	case reflect.Uint64, reflect.Uint:
+		return typeEncoder{enc, bigIntegerType}
+	case reflect.Uint8:
+		return typeEncoder{enc, byteType}
+	case reflect.Float32:
+		return typeEncoder{enc, floatType}
+	case reflect.Float64:
+		return typeEncoder{enc, doubleType}
+	default:
+		return nil
+	}
+}
+
+// DecoderOfNative returns a value decoder of a native type.
+func (decodeExtension) DecoderOfNative(typ reflect2.Type) jsoniter.ValDecoder {
+	switch typ.Kind() {
+	case reflect.Float64:
+		return float64Decoder{typ}
+	default:
+		return nil
+	}
+}
+
+// DecoratorOfNative decorates a value decoder of a native type.
+func (decodeExtension) DecoratorOfNative(typ reflect2.Type, dec jsoniter.ValDecoder) jsoniter.ValDecoder {
+	switch typ.Kind() {
+	case reflect.Bool:
+		return dec
+	case reflect.String:
+		return typeDecoder{dec, typeCheckerFunc(func(Type) error { return nil })}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return typeDecoder{dec, integerTypes}
+	case reflect.Float32:
+		return typeDecoder{dec, floatTypes}
+	case reflect.Float64:
+		return typeDecoder{dec, doubleTypes}
+	default:
+		return nil
+	}
+}
+
+type float64Encoder struct {
+	reflect2.Type
+}
+
+func (enc float64Encoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return enc.UnsafeIndirect(ptr).(float64) == 0
+}
+
+func (enc float64Encoder) Encode(ptr unsafe.Pointer, stream *jsoniter.Stream) {
+	f := enc.UnsafeIndirect(ptr).(float64)
+	switch {
+	case math.IsNaN(f):
+		stream.WriteString("NaN")
+	case math.IsInf(f, 1):
+		stream.WriteString("Infinity")
+	case math.IsInf(f, -1):
+		stream.WriteString("-Infinity")
+	default:
+		stream.WriteFloat64(f)
+	}
+}
+
+type float64Decoder struct {
+	reflect2.Type
+}
+
+var (
+	integerTypes = Types{byteType, int16Type, int32Type, int64Type, bigIntegerType}
+	floatTypes   = append(integerTypes, floatType, bigDecimal)
+	doubleTypes  = append(floatTypes, doubleType)
+)
+
+func (dec float64Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	var val float64
+	switch next := iter.WhatIsNext(); next {
+	case jsoniter.NumberValue:
+		val = iter.ReadFloat64()
+	case jsoniter.StringValue:
+		switch str := iter.ReadString(); str {
+		case "NaN":
+			val = math.NaN()
+		case "Infinity":
+			val = math.Inf(1)
+		case "-Infinity":
+			val = math.Inf(-1)
+		default:
+			iter.ReportError("decode float64", "invalid value "+str)
+		}
+	default:
+		iter.ReportError("decode float64", fmt.Sprintf("unexpected value type: %d", next))
+	}
+
+	if iter.Error == nil || iter.Error == io.EOF {
+		// nolint: gas
+		dec.UnsafeSet(ptr, unsafe.Pointer(&val))
+	}
+}