primitives.go raw

   1  /**
   2   * Copyright 2024 ByteDance Inc.
   3   *
   4   * Licensed under the Apache License, Version 2.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7   *
   8   *     http://www.apache.org/licenses/LICENSE-2.0
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16  
  17  package alg
  18  
  19  import (
  20  	"encoding"
  21  	"encoding/json"
  22  	"reflect"
  23  	"unsafe"
  24  
  25  	"github.com/bytedance/sonic/internal/encoder/vars"
  26  	"github.com/bytedance/sonic/internal/resolver"
  27  	"github.com/bytedance/sonic/internal/rt"
  28  )
  29  
  30  func Compact(p *[]byte, v []byte) error {
  31  	buf := vars.NewBuffer()
  32  	err := json.Compact(buf, v)
  33  
  34  	/* check for errors */
  35  	if err != nil {
  36  		return err
  37  	}
  38  
  39  	/* add to result */
  40  	v = buf.Bytes()
  41  	*p = append(*p, v...)
  42  
  43  	/* return the buffer into pool */
  44  	vars.FreeBuffer(buf)
  45  	return nil
  46  }
  47  
  48  func EncodeNil(rb *[]byte) error {
  49  	*rb = append(*rb, 'n', 'u', 'l', 'l')
  50  	return nil
  51  }
  52  
  53  // func Make_EncodeTypedPointer(computor func(*rt.GoType, ...interface{}) (interface{}, error)) func(*[]byte, *rt.GoType, *unsafe.Pointer, *vars.Stack, uint64) error {
  54  // 	return func(buf *[]byte, vt *rt.GoType, vp *unsafe.Pointer, sb *vars.Stack, fv uint64) error {
  55  // 		if vt == nil {
  56  // 			return EncodeNil(buf)
  57  // 		} else if fn, err := vars.FindOrCompile(vt, (fv&(1<<BitPointerValue)) != 0, computor); err != nil {
  58  // 			return err
  59  // 		} else if vt.Indirect() {
  60  // 			err := fn(buf, *vp, sb, fv)
  61  // 			return err
  62  // 		} else {
  63  // 			err := fn(buf, unsafe.Pointer(vp), sb, fv)
  64  // 			return err
  65  // 		}
  66  // 	}
  67  // }
  68  
  69  func EncodeJsonMarshaler(buf *[]byte, val json.Marshaler, opt uint64) error {
  70  	if ret, err := val.MarshalJSON(); err != nil {
  71  		return err
  72  	} else {
  73  		if opt&(1<<BitCompactMarshaler) != 0 {
  74  			return Compact(buf, ret)
  75  		}
  76  		if opt&(1<<BitNoValidateJSONMarshaler) == 0 {
  77  			if ok, s := Valid(ret); !ok {
  78  				return vars.Error_marshaler(ret, s)
  79  			}
  80  		}
  81  		*buf = append(*buf, ret...)
  82  		return nil
  83  	}
  84  }
  85  
  86  func EncodeTextMarshaler(buf *[]byte, val encoding.TextMarshaler, opt uint64) error {
  87  	if ret, err := val.MarshalText(); err != nil {
  88  		return err
  89  	} else {
  90  		if opt&(1<<BitNoQuoteTextMarshaler) != 0 {
  91  			*buf = append(*buf, ret...)
  92  			return nil
  93  		}
  94  		*buf = Quote(*buf, rt.Mem2Str(ret), false)
  95  		return nil
  96  	}
  97  }
  98  
  99  func IsZero(val unsafe.Pointer, fv *resolver.FieldMeta) bool {
 100  	rv := reflect.NewAt(fv.Type, val).Elem()
 101  	b1 := fv.IsZero == nil && rv.IsZero()
 102  	b2 := fv.IsZero != nil && fv.IsZero(rv)
 103  	return  b1 || b2
 104  }
 105