active3/base/apack/pkjson/packer.go

// ------------------------------------------------------------------------
// 🚀 Project active3
// 🔗 Active Thing (activething.com) git.activething.com/go
//
//    File name  packer.go
// ✍️ Created by DEV
// 📅 Modified   10/05/2024
//
// 🔒 Copyright 2024 activething.com
//  
// 📜 LICENSE --------------------------------------------------------------
// 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 pkjson

import (
	"apack"
	"apack/pstate"
	"cdcs/cjson"
	"reflect"
	"rsls"
	"sync"
	"time"
)


type (

	Packer 	struct {
		f 	apack.Flags
	}


	PackerFnc func (packer *Packer)
)


func NewPacker (options ...PackerFnc) *Packer {
	p := &Packer {

	}
	for _,o:=range options {
		o(p)
	}
	return p
}


func (p Packer) Pack (value any) rsls.Bytes {

	b := newBuilder(p.f)
	b.release()

	b.Any(value)
	if b.Err != nil {
		return rsls.MakeBytesError(b.Err)
	}
	return rsls.MakeBytesSuccess(b.B.Bytes())
}



func (b *Builder) packString (value string, flags apack.Flags) {
	if len(value) == 0 {
		b.B.Write2Byte('"','"')
		return
	}
	if flags.Encrypted() {
		b.packEncrypted([]byte(value),flags)
		return
	}
	if flags.Binary() {
		b.packBinary([]byte(value),flags)
		return
	}
	cjson.WriteString(b.B,value,flags.EscapeHTML())
}

func (b *Builder) packEncrypted (value []byte, flags apack.Flags) {
	if b.Encrypter == nil {
		b.SetError(apack.G.ErrInvalidEncrypter)
		return
	}
	rs := b.Encrypter.Encrypt(value)
	if !rs.Ok() {
		b.SetError(rs.Fail())
		return
	}
	if !flags.Binary() {
		flags|=apack.FlagBinary64
	}
	b.packBinary (rs.Value(),flags)
}

func (b *Builder) packBinary (value []byte, flags apack.Flags) {
	if flags.Bin64() {
		b.SetError(cjson.WriteBase64(b.B,value))
		return
	}
	if flags.Bin32() {
		b.SetError(cjson.WriteBase64(b.B,value))
		return
	}
}



func packListString (p *Builder, list []string, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			p.packString(v, flags)
			if p.Err != nil {
				return
			}
		}
	})
}


func packListError (p *Builder, list []error, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			if v == nil {
				b.B.WOQ(true,'"',cjson.G.NullValue)
				continue
			}
			p.packString(v.Error(), apack.FlagScapeHTML)
		}
	})
}


func packListBool (p *Builder, list []bool, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			cjson.WriteBool(p.B,v,flags.Quote())
		}
	})
}


func packListInt  [T int | int8 | int16 | int32 | int64 | time.Duration](p *Builder, list []T, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			cjson.WriteInt(p.B,int64(v),flags.Quote())
		}
	})
}


func packListUInt [T uint | uint8 | uint16 | uint32 | uint64|uintptr](p *Builder, list []T, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			cjson.WriteUint(p.B,uint64(v),flags.Quote())
		}
	})
}


func packListFloat[T float32 | float64](p *Builder, list []T, flags apack.Flags, bits int) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			cjson.WriteFloat(p.B,float64(v),bits,flags.Quote())
		}
	})
}


func packListDate (p *Builder, list []time.Time, flags apack.Flags) {
	p.makeLevel(pstate.ModeList,list == nil, len(list) == 0,func(b *Builder){
		for i,v := range list {
			if i > 0 {
				p.B.WriteByte(sep)
			}
			cjson.WriteTime(p.B,v,flags.DateFormat(),flags.Quote())
		}
	})
}


func packReflected(rtype reflect.Type) func (b *Builder, v reflect.Value) {
	if fn,hs := g.packersCache.Load(rtype); hs {
		return fn.(func (builder *Builder,value reflect.Value))
	}
	var wg sync.WaitGroup
	var fn func(*Builder, reflect.Value)

	fi,ld := g.packersCache.LoadOrStore(rtype,func(builder *Builder, value reflect.Value){
		wg.Wait()
		fn(builder,value)
	})
	if ld {
		return fi.(func(builder *Builder, value reflect.Value))
	}

	fn = makePackFn(rtype)
	wg.Done()

	g.packersCache.Store(rtype,fn)
	return fn
}


func makePackFn(rtype reflect.Type) func(b *Builder, v reflect.Value) {
	switch rtype.Kind() {

	case reflect.Bool 	: return func(b *Builder, v reflect.Value) { b.Bool(v.Bool()) }

	case reflect.String	: return func(b *Builder, v reflect.Value) { b.String(v.String()) }

	case reflect.Int,
		reflect.Int8,
		reflect.Int16,
		reflect.Int32,
		reflect.Int64	: return func(b *Builder, v reflect.Value) { b.Int64(v.Int()) }

	case reflect.Uint,
		reflect.Uint8,
		reflect.Uint16,
		reflect.Uint32,
		reflect.Uint64,
		reflect.Uintptr	: return func(b *Builder, v reflect.Value) { b.Uint64(v.Uint()) }

	case reflect.Float32: return func(b *Builder, v reflect.Value) { b.float(v.Float(),32) }
	case reflect.Float64: return func(b *Builder, v reflect.Value) { b.float(v.Float(),64) }


	default:
		return func(b *Builder, v reflect.Value) {b.unsupportedType(v) }
	}
}