Method readSingleValue

go/fory/map.go:401–473

readSingleValue reads a single key or value with proper ref/type handling

(ctx *ReadContext, buf *ByteBuffer, ctxErr *Error, isDeclared, trackRef bool, staticType reflect.Type, declaredSer Serializer, resolver *TypeResolver, refResolver *RefResolver)

// readSingleValue reads a single key or value with proper ref/type handling
func (s mapSerializer) readSingleValue(ctx *ReadContext, buf *ByteBuffer, ctxErr *Error, isDeclared, trackRef bool, staticType reflect.Type, declaredSer Serializer, resolver *TypeResolver, refResolver *RefResolver) reflect.Value {
	// When ref tracking AND not declared, ref flag comes before type info
	if trackRef && !isDeclared {
		refID, err := refResolver.TryPreserveRefId(buf)
		if err != nil {
			ctx.SetError(FromError(err))
			return reflect.Value{}
		}
		if refID < int32(NotNullValueFlag) {
			return refResolver.GetReadObject(refID)
		}

		// Read type info and data
		ti := resolver.ReadTypeInfo(buf, ctxErr)
		if ctxErr.HasError() {
			return reflect.Value{}
		}

		ser := ti.Serializer
		valType := ti.Type
		if valType == nil {
			valType = staticType
		}
		valType, ser = wrapMapSerializerIfNeeded(staticType, valType, ser)
		v := reflect.New(valType).Elem()
		ser.ReadData(ctx, v)
		if ctx.HasError() {
			return reflect.Value{}
		}
		if _, ok := ser.(*ptrToValueSerializer); !ok {
			refResolver.Reference(v)
		}
		return v
	}

	// Read type info if not declared
	var typeInfo *TypeInfo
	var ser Serializer
	valType := staticType

	if !isDeclared {
		typeInfo = resolver.ReadTypeInfo(buf, ctxErr)
		if ctxErr.HasError() {
			return reflect.Value{}
		}
		ser = typeInfo.Serializer
		valType = typeInfo.Type
		valType, ser = wrapMapSerializerIfNeeded(staticType, valType, ser)
	} else {
		ser = declaredSer
		if ser == nil {
			ser, _ = resolver.getSerializerByType(staticType, false)
		}
	}

	if valType == nil {
		valType = staticType
	}