active3/base/apack/pkjson/reflected.go

// ------------------------------------------------------------------------
// 🚀 Project active3
// 🔗 Active Thing (activething.com) git.activething.com/go
//
//    File name  reflected.go
// ✍️ Created by DEV
// 📅 Modified   25/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"
	"blds"
	"cdcs/cjson"
	"encoding/json"
	"reflect"
	"sync"
)


type (
	
	PackReflectedFnc func(b *Builder, v reflect.Value)
)


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

	wg.Add(1)

	fs := PackReflectedFnc(func(builder *Builder, value reflect.Value){
		wg.Wait()
		fn(builder,value)
	})


	fi,ld := g.packersCache.LoadOrStore(rtype,fs)
	if ld {
		return fi.(PackReflectedFnc)
	}

	fn = makePackReflectedFn(rtype)
	wg.Done()

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


func makePackReflectedFn(rtype reflect.Type) PackReflectedFnc {

	if rtype.Implements(g.buildableType) {
		return func (b *Builder, v reflect.Value) {
			b.Buildable(v.Interface().(blds.Buildable))
		}
	}

	if rtype.Implements(g.jsonMarshalerType) {
		return func (b *Builder, v reflect.Value) {
			b.Marshaller(v.Interface().(json.Marshaler))
		}
	}


	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) }

	case reflect.Pointer:
		eleFn := packReflected(rtype.Elem())
		return func(b *Builder, v reflect.Value) {
			if v.IsNil() {
				b.B.W(cjson.G.NullValue)
				return
			}
			b.Level++
			if b.Level > maxCyclesAfter {
				if fn,ok := b.CheckCycle(v.Interface()); ok {
					defer fn()
				} else {
					return
				}
			}
			eleFn(b,v.Elem())
			b.Level--
		}

	case reflect.Interface:
		return func(b *Builder, v reflect.Value) {
			if v.IsNil() {
				b.B.W(cjson.G.NullValue)
				return
			}
			packReflected(v.Elem().Type())(b,v.Elem())
		}

	case reflect.Slice,
		reflect.Array:
		return (*newRList(rtype)).pack

	case reflect.Map :
		return (*newRMap(rtype)).pack


	case reflect.Struct:
		return (*newRObject(rtype)).pack

	default:
		return packReflectedInvalid
	}
}






func packReflectedInvalid (b  *Builder, _ reflect.Value) {
	b.SetError(apack.G.ErrInvalidValue) }