You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
509 lines
9.9 KiB
509 lines
9.9 KiB
// ------------------------------------------------------------------------
|
|
// Project atila
|
|
// Active Thing (activething.com) git.activething.com/go
|
|
//
|
|
// File name packer.go
|
|
// Created by DEV
|
|
// Modified 23/01/2024
|
|
//
|
|
// Copyright 2024 activething.com
|
|
// ------------------------------------------------------------------------
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// ------------------------------------------------------------------------
|
|
|
|
package pjson
|
|
|
|
import (
|
|
"activething.com/go/gogo/core/bins"
|
|
"activething.com/go/gogo/core/errs"
|
|
"activething.com/go/gogo/core/opts"
|
|
"activething.com/go/gogo/packs"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"time"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
type (
|
|
|
|
Packer struct {
|
|
options Options
|
|
state *packs.State
|
|
}
|
|
|
|
|
|
)
|
|
|
|
func NewPacker (options ...opts.OptionFnc[Packer]) *Packer {
|
|
return opts.Apply(&Packer{
|
|
options: Options{
|
|
Flags: JSONFlagQuote | JSONFlagEscapeHTML,
|
|
dateLayout: time.RFC822Z,
|
|
},
|
|
state : packs.NewState(),
|
|
})
|
|
}
|
|
|
|
|
|
|
|
func (p *Packer) Bytes () []byte {
|
|
defer p.Reset()
|
|
return append([]byte(nil),p.state.Bytes()...)
|
|
}
|
|
|
|
|
|
func (p *Packer) Error () error {
|
|
return p.state.Error
|
|
}
|
|
|
|
|
|
func (p *Packer) Reset () {
|
|
p.state.Reset()
|
|
p.options.reset()
|
|
}
|
|
|
|
|
|
|
|
func (p *Packer) Pack (value any) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if value == nil {
|
|
if p.options.Quote() {
|
|
p.state.WriteByte('"')
|
|
}
|
|
p.state.Write(G.nullValue)
|
|
if p.options.Quote() {
|
|
p.state.WriteByte('"')
|
|
}
|
|
p.state.Node.Count++
|
|
return
|
|
}
|
|
|
|
switch v := value.(type) {
|
|
|
|
case bool : p.PackBool(v)
|
|
case string : p.PackString(v)
|
|
|
|
case uint : p.PackUInt64(uint64(v))
|
|
case uint8 : p.PackUInt64(uint64(v))
|
|
case uint16 : p.PackUInt64(uint64(v))
|
|
case uint32 : p.PackUInt64(uint64(v))
|
|
case uint64 : p.PackUInt64(v)
|
|
|
|
case int : p.PackInt64(int64(v))
|
|
case int8 : p.PackInt64(int64(v))
|
|
case int16 : p.PackInt64(int64(v))
|
|
case int32 : p.PackInt64(int64(v))
|
|
case int64 : p.PackInt64(v)
|
|
|
|
case float32: p.packFloat(float64(v),32)
|
|
case float64: p.packFloat(v,64)
|
|
|
|
case reflect.Value : p.Pack(v.Elem())
|
|
|
|
default:
|
|
if pb,is := value.(packs.Packabler); is {
|
|
d,e := pb.Build(p)
|
|
if p.state.SetError(e) {
|
|
return
|
|
}
|
|
_,_ = p.state.Write(d)
|
|
p.state.Node.Count++
|
|
return
|
|
}
|
|
if ms,is := value.(json.Marshaler); is {
|
|
d,e := ms.MarshalJSON()
|
|
if p.state.SetError(e) {
|
|
return
|
|
}
|
|
_,_ = p.state.Write(d)
|
|
p.state.Node.Count++
|
|
return
|
|
}
|
|
|
|
rv := reflect.ValueOf(value)
|
|
switch rv.Kind() {
|
|
case reflect.Slice,reflect.Array :
|
|
p.packListReflected(rv)
|
|
return
|
|
case reflect.Map :
|
|
p.packMapReflected(rv)
|
|
return
|
|
case reflect.Struct:
|
|
p.packObjectReflected(rv)
|
|
return
|
|
}
|
|
|
|
p.state.SetError(packs.G.ErrUnsupportedType)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Packer) PackRaw (value []byte) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if value == nil {
|
|
_,_ = p.state.Write(G.nullValue)
|
|
return
|
|
}
|
|
|
|
if p.options.Quote() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
_,_ = p.state.Write(value)
|
|
if p.options.Quote() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
|
|
func (p *Packer) PackBinary (value []byte) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if value == nil {
|
|
_,_ = p.state.Write(G.nullValue)
|
|
return
|
|
}
|
|
if len(value) == 0 {
|
|
p.state.Write2Byte('"','"')
|
|
return
|
|
}
|
|
_ = p.state.WriteByte('"')
|
|
ln := base64.StdEncoding.EncodedLen(len(value))
|
|
if ln <= len(p.state.Temp) {
|
|
dst := p.state.Temp[:ln]
|
|
base64.StdEncoding.Encode(dst, value)
|
|
_,_= p.state.Write(dst)
|
|
} else if ln <= 1024 {
|
|
dst := make([]byte, ln)
|
|
base64.StdEncoding.Encode(dst, value)
|
|
_,_ = p.state.Write(dst)
|
|
} else {
|
|
enc := base64.NewEncoder(base64.StdEncoding, p.state)
|
|
_,_ = enc.Write(value)
|
|
p.state.SetError(enc.Close())
|
|
return
|
|
}
|
|
_ = p.state.WriteByte('"')
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
func (p *Packer) PackString (value string) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if len(value) == 0 {
|
|
p.state.Write2Byte('"','"')
|
|
} else {
|
|
p.packString(value,p.options.EscapeHTML())
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
func (p *Packer) packString(s string, scapeHTML bool) {
|
|
|
|
_ = p.state.WriteByte('"')
|
|
start := 0
|
|
for i := 0; i < len(s); {
|
|
if b := s[i]; b < utf8.RuneSelf {
|
|
if !G.jsonChars[b].isHtmlUnsafe() || (!scapeHTML && !G.jsonChars[b].isUnsafe()) {
|
|
i++
|
|
continue
|
|
}
|
|
|
|
if start < i {
|
|
_,_ = p.state.WriteString(s[start:i])
|
|
}
|
|
_ = p.state.WriteByte('\\')
|
|
switch b {
|
|
case '\\', '"': _ = p.state.WriteByte(b)
|
|
case '\n': _ = p.state.WriteByte('n')
|
|
case '\r': _ = p.state.WriteByte('r')
|
|
case '\t': _ = p.state.WriteByte('t')
|
|
default:
|
|
_,_ = p.state.WriteString(`u00`)
|
|
p.state.Write2Byte(G.hex[b>>4], G.hex[b&0xF])
|
|
}
|
|
i++
|
|
start = i
|
|
continue
|
|
}
|
|
c, size := utf8.DecodeRuneInString(s[i:])
|
|
if c == utf8.RuneError && size == 1 {
|
|
if start < i {
|
|
_,_ = p.state.WriteString(s[start:i])
|
|
}
|
|
_,_ = p.state.WriteString(`\ufffd`)
|
|
i += size
|
|
start = i
|
|
continue
|
|
}
|
|
|
|
if c == '\u2028' || c == '\u2029' {
|
|
if start < i {
|
|
_,_ = p.state.WriteString(s[start:i])
|
|
}
|
|
_,_ = p.state.WriteString(`\u202`)
|
|
_ = p.state.WriteByte(G.hex[c&0xF])
|
|
i += size
|
|
start = i
|
|
continue
|
|
}
|
|
i += size
|
|
}
|
|
if start < len(s) {
|
|
_,_ = p.state.WriteString(s[start:])
|
|
}
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
|
|
|
|
|
|
func (p *Packer) PackBool (value bool) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
if value {
|
|
_,_ = p.state.Write(G.trueValue)
|
|
} else {
|
|
_,_ = p.state.Write(G.falseValue)
|
|
}
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
func (p *Packer) PackInt8 (value int8) { p.PackInt64(int64(value)) }
|
|
func (p *Packer) PackInt16 (value int16) { p.PackInt64(int64(value)) }
|
|
func (p *Packer) PackInt32 (value int32) { p.PackInt64(int64(value)) }
|
|
func (p *Packer) PackInt64 (value int64) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
if value == 0 {
|
|
_ = p.state.WriteByte('0')
|
|
} else {
|
|
p.state.WriteIntStr(value, 10)
|
|
}
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
func (p *Packer) PackUInt8 (value uint8 ) { p.PackUInt64(uint64(value)) }
|
|
func (p *Packer) PackUInt16 (value uint16) { p.PackUInt64(uint64(value)) }
|
|
func (p *Packer) PackUInt32 (value uint32) { p.PackUInt64(uint64(value)) }
|
|
func (p *Packer) PackUInt64 (value uint64) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
if value == 0 {
|
|
_ = p.state.WriteByte('0')
|
|
} else {
|
|
p.state.WriteUIntStr(value, 10)
|
|
}
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
func (p *Packer) PackFloat32 (value float32) { p.packFloat(float64(value),32) }
|
|
func (p *Packer) PackFloat64 (value float64) { p.packFloat(value,64) }
|
|
|
|
func (p *Packer) packFloat (value float64, bits int) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
b := stringifyFloat(p.state.Temp[:0], value,bits)
|
|
if b == nil {
|
|
p.state.SetError(packs.G.ErrInvalidValue)
|
|
return
|
|
}
|
|
if p.options.QuoteNumbers() {
|
|
_ = p.state.WriteByte('"')
|
|
}
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
|
|
func (p *Packer) PackDate (value time.Time) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
_ = p.state.WriteByte('"')
|
|
p.state.AppendWith(bins.AppendFnc(func(d []byte) []byte {
|
|
return value.AppendFormat(d,p.options.dateLayout)
|
|
}))
|
|
_ = p.state.WriteByte('"')
|
|
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
|
|
func (p *Packer) PackList (builder func(packer packs.ListPacker)) {
|
|
p.packCompound(packs.NodeKindList,'[',']',func(pk *Packer) { builder (pk) })
|
|
}
|
|
|
|
func (p *Packer) PackMap (builder func(packer packs.MapPacker )) {
|
|
p.packCompound(packs.NodeKindMap,'{','}',func(pk *Packer) { builder (pk) })
|
|
}
|
|
|
|
func (p *Packer) PackObject(builder func(packer packs.ObjectPacker)) {
|
|
p.packCompound(packs.NodeKindObject,'{','}',func(pk *Packer) { builder (pk) })
|
|
}
|
|
|
|
|
|
|
|
|
|
func (p *Packer) packCompound(kind packs.NodeKind, opening, closing byte, buildFnc func(*Packer)) {
|
|
dn := false
|
|
defer func(d *bool) {
|
|
if !(*d) {
|
|
p.state.SetError(errs.ToError(recover()))
|
|
}
|
|
}(&dn)
|
|
|
|
|
|
if p.state.Open(kind) {
|
|
fmt.Printf("Node Count %d\n",p.state.Node.Count)
|
|
_ = p.state.WriteByte(opening)
|
|
|
|
/*
|
|
if !p.state.SetValue() {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
*/
|
|
buildFnc(p)
|
|
|
|
if p.state.Error == nil {
|
|
if p.state.Close() {
|
|
_ = p.state.WriteByte(closing)
|
|
}
|
|
}
|
|
}
|
|
dn = true
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func (p *Packer) addSep () *Packer {
|
|
if p.state.Node.Count > 0 {
|
|
_ = p.state.WriteByte(',')
|
|
}
|
|
return p
|
|
}
|
|
|
|
|
|
func (p *Packer) addKey (key any, call func(*Packer)) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
p.addSep()
|
|
k := stringifyKey(p.state.Temp[0:],key)
|
|
if k == nil {
|
|
p.state.SetError(packs.G.ErrInvalidKey)
|
|
return
|
|
}
|
|
|
|
ks := string(k)
|
|
if !p.options.IgnoreKeys() && !p.state.SetKey(ks) {
|
|
return
|
|
}
|
|
|
|
p.packString(ks,p.options.EscapeHTML())
|
|
_ = p.state.WriteByte(':')
|
|
call(p)
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
|
|
func (p *Packer) addField (name string, call func(*Packer)) {
|
|
if p.state.Error != nil {
|
|
panic(p.state.Error)
|
|
}
|
|
|
|
p.addSep()
|
|
if !p.options.IgnoreKeys() && !p.state.SetKey(name) {
|
|
return
|
|
}
|
|
|
|
p.packString(name,p.options.EscapeHTML())
|
|
_ = p.state.WriteByte(':')
|
|
call(p)
|
|
p.state.Node.Count++
|
|
}
|
|
|
|
|
|
func (p *Packer) packListReflected (value reflect.Value) {
|
|
//todo
|
|
}
|
|
|
|
func (p *Packer) packMapReflected (value reflect.Value) {
|
|
//todo
|
|
}
|
|
|
|
func (p *Packer) packObjectReflected (value reflect.Value) {
|
|
//todo
|
|
}
|
|
|