cmd/bpa-operator/vendor/github.com/json-iterator/go/reflect_marshaler.go

   1 package jsoniter
   2
   3 import (
   4         "encoding"
   5         "encoding/json"
   6         "github.com/modern-go/reflect2"
   7         "unsafe"
   8 )
   9
  10 var marshalerType = reflect2.TypeOfPtr((*json.Marshaler)(nil)).Elem()
  11 var unmarshalerType = reflect2.TypeOfPtr((*json.Unmarshaler)(nil)).Elem()
  12 var textMarshalerType = reflect2.TypeOfPtr((*encoding.TextMarshaler)(nil)).Elem()
  13 var textUnmarshalerType = reflect2.TypeOfPtr((*encoding.TextUnmarshaler)(nil)).Elem()
  14
  15 func createDecoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValDecoder {
  16         ptrType := reflect2.PtrTo(typ)
  17         if ptrType.Implements(unmarshalerType) {
  18                 return &referenceDecoder{
  19                         &unmarshalerDecoder{ptrType},
  20                 }
  21         }
  22         if ptrType.Implements(textUnmarshalerType) {
  23                 return &referenceDecoder{
  24                         &textUnmarshalerDecoder{ptrType},
  25                 }
  26         }
  27         return nil
  28 }
  29
  30 func createEncoderOfMarshaler(ctx *ctx, typ reflect2.Type) ValEncoder {
  31         if typ == marshalerType {
  32                 checkIsEmpty := createCheckIsEmpty(ctx, typ)
  33                 var encoder ValEncoder = &directMarshalerEncoder{
  34                         checkIsEmpty: checkIsEmpty,
  35                 }
  36                 return encoder
  37         }
  38         if typ.Implements(marshalerType) {
  39                 checkIsEmpty := createCheckIsEmpty(ctx, typ)
  40                 var encoder ValEncoder = &marshalerEncoder{
  41                         valType:      typ,
  42                         checkIsEmpty: checkIsEmpty,
  43                 }
  44                 return encoder
  45         }
  46         ptrType := reflect2.PtrTo(typ)
  47         if ctx.prefix != "" && ptrType.Implements(marshalerType) {
  48                 checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
  49                 var encoder ValEncoder = &marshalerEncoder{
  50                         valType:      ptrType,
  51                         checkIsEmpty: checkIsEmpty,
  52                 }
  53                 return &referenceEncoder{encoder}
  54         }
  55         if typ == textMarshalerType {
  56                 checkIsEmpty := createCheckIsEmpty(ctx, typ)
  57                 var encoder ValEncoder = &directTextMarshalerEncoder{
  58                         checkIsEmpty:  checkIsEmpty,
  59                         stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
  60                 }
  61                 return encoder
  62         }
  63         if typ.Implements(textMarshalerType) {
  64                 checkIsEmpty := createCheckIsEmpty(ctx, typ)
  65                 var encoder ValEncoder = &textMarshalerEncoder{
  66                         valType:       typ,
  67                         stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
  68                         checkIsEmpty:  checkIsEmpty,
  69                 }
  70                 return encoder
  71         }
  72         // if prefix is empty, the type is the root type
  73         if ctx.prefix != "" && ptrType.Implements(textMarshalerType) {
  74                 checkIsEmpty := createCheckIsEmpty(ctx, ptrType)
  75                 var encoder ValEncoder = &textMarshalerEncoder{
  76                         valType:       ptrType,
  77                         stringEncoder: ctx.EncoderOf(reflect2.TypeOf("")),
  78                         checkIsEmpty:  checkIsEmpty,
  79                 }
  80                 return &referenceEncoder{encoder}
  81         }
  82         return nil
  83 }
  84
  85 type marshalerEncoder struct {
  86         checkIsEmpty checkIsEmpty
  87         valType      reflect2.Type
  88 }
  89
  90 func (encoder *marshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
  91         obj := encoder.valType.UnsafeIndirect(ptr)
  92         if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
  93                 stream.WriteNil()
  94                 return
  95         }
  96         bytes, err := json.Marshal(obj)
  97         if err != nil {
  98                 stream.Error = err
  99         } else {
 100                 stream.Write(bytes)
 101         }
 102 }
 103
 104 func (encoder *marshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
 105         return encoder.checkIsEmpty.IsEmpty(ptr)
 106 }
 107
 108 type directMarshalerEncoder struct {
 109         checkIsEmpty checkIsEmpty
 110 }
 111
 112 func (encoder *directMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 113         marshaler := *(*json.Marshaler)(ptr)
 114         if marshaler == nil {
 115                 stream.WriteNil()
 116                 return
 117         }
 118         bytes, err := marshaler.MarshalJSON()
 119         if err != nil {
 120                 stream.Error = err
 121         } else {
 122                 stream.Write(bytes)
 123         }
 124 }
 125
 126 func (encoder *directMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
 127         return encoder.checkIsEmpty.IsEmpty(ptr)
 128 }
 129
 130 type textMarshalerEncoder struct {
 131         valType       reflect2.Type
 132         stringEncoder ValEncoder
 133         checkIsEmpty  checkIsEmpty
 134 }
 135
 136 func (encoder *textMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 137         obj := encoder.valType.UnsafeIndirect(ptr)
 138         if encoder.valType.IsNullable() && reflect2.IsNil(obj) {
 139                 stream.WriteNil()
 140                 return
 141         }
 142         marshaler := (obj).(encoding.TextMarshaler)
 143         bytes, err := marshaler.MarshalText()
 144         if err != nil {
 145                 stream.Error = err
 146         } else {
 147                 str := string(bytes)
 148                 encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
 149         }
 150 }
 151
 152 func (encoder *textMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
 153         return encoder.checkIsEmpty.IsEmpty(ptr)
 154 }
 155
 156 type directTextMarshalerEncoder struct {
 157         stringEncoder ValEncoder
 158         checkIsEmpty  checkIsEmpty
 159 }
 160
 161 func (encoder *directTextMarshalerEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 162         marshaler := *(*encoding.TextMarshaler)(ptr)
 163         if marshaler == nil {
 164                 stream.WriteNil()
 165                 return
 166         }
 167         bytes, err := marshaler.MarshalText()
 168         if err != nil {
 169                 stream.Error = err
 170         } else {
 171                 str := string(bytes)
 172                 encoder.stringEncoder.Encode(unsafe.Pointer(&str), stream)
 173         }
 174 }
 175
 176 func (encoder *directTextMarshalerEncoder) IsEmpty(ptr unsafe.Pointer) bool {
 177         return encoder.checkIsEmpty.IsEmpty(ptr)
 178 }
 179
 180 type unmarshalerDecoder struct {
 181         valType reflect2.Type
 182 }
 183
 184 func (decoder *unmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
 185         valType := decoder.valType
 186         obj := valType.UnsafeIndirect(ptr)
 187         unmarshaler := obj.(json.Unmarshaler)
 188         iter.nextToken()
 189         iter.unreadByte() // skip spaces
 190         bytes := iter.SkipAndReturnBytes()
 191         err := unmarshaler.UnmarshalJSON(bytes)
 192         if err != nil {
 193                 iter.ReportError("unmarshalerDecoder", err.Error())
 194         }
 195 }
 196
 197 type textUnmarshalerDecoder struct {
 198         valType reflect2.Type
 199 }
 200
 201 func (decoder *textUnmarshalerDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
 202         valType := decoder.valType
 203         obj := valType.UnsafeIndirect(ptr)
 204         if reflect2.IsNil(obj) {
 205                 ptrType := valType.(*reflect2.UnsafePtrType)
 206                 elemType := ptrType.Elem()
 207                 elem := elemType.UnsafeNew()
 208                 ptrType.UnsafeSet(ptr, unsafe.Pointer(&elem))
 209                 obj = valType.UnsafeIndirect(ptr)
 210         }
 211         unmarshaler := (obj).(encoding.TextUnmarshaler)
 212         str := iter.ReadString()
 213         err := unmarshaler.UnmarshalText([]byte(str))
 214         if err != nil {
 215                 iter.ReportError("textUnmarshalerDecoder", err.Error())
 216         }
 217 }