go/packs/reflects/rstruct.go

// ------------------------------------------------------------------------
//   Project atila
//   Active Thing (activething.com) git.activething.com/go
//
//   File name  rRFields_type.go
//   Created by DEV
//   Modified   26/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 reflects

type (
	
	RStruct 		struct {
		Fields    	RFields
		NameIndex 	map[string]int
	}
)

/*

func NewRStruct (rtype reflect.Type) *RStruct {
	res := &RStruct{
		Fields   : make(RFields,0,rtype.NumField()),
		NameIndex: make(map[string]int),
	}

	cur := RFields{}
	nxt := RFields{{ RType: rtype }}

	var (
		cnt,nxc map[reflect.Type]int
		vis map[reflect.Type]struct{}
		nms bytes.Buffer
	)

	for len(nxt) > 0 {
		cur, nxt = nxt, cur[:0]
		cnt, nxc = nxc, map[reflect.Type]int{}

		for _,f := range cur {
			if _,h := vis[f.RType]; h {
				continue
			}
			vis[f.RType]=struct{}{}

			for i :=0; i<f.RType.NumField(); i++ {
				sf := f.RType.Field(i)
				if sf.Anonymous {
					st := sf.Type
					if st.Kind() == reflect.Pointer {
						st = st.Elem()
					}
					if !sf.IsExported() && st.Kind() != reflect.Struct {
						continue
					}
				} else if !sf.IsExported() {
					continue
				}

				nm := false
				tags,ok := parseTag(sf,"json",nil)
				if ok {
					if tags.Has("-") {
						continue
					}
					if isValidTag(tags[0]) {
						nm=true
					}
				}

				ft := sf.Type
				if ft.Name() == "" && ft.Kind() == reflect.Pointer {
					ft=ft.Elem()
				}


				//qt := false
				//if tags.Has("string") {
				//	switch ft.Kind() {
				//	case reflect.Bool,
				//		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
				//		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
				//		reflect.Float32, reflect.Float64,
				//		reflect.String:
				//		qt = true
				//	}
				//}



				index := make([]int, len(f.Index)+1)
				copy(index, f.Index)
				index[len(f.Index)] = i



				var name string
				if nm || sf.Anonymous || ft.Kind() != reflect.Struct {
					if nm {
						name = tags[0]
					} else {
						name = sf.Name
					}

					res.Fields = append(res.Fields, RField{
						RField: sf,
						RType:  ft,
						Name:   name,
						BName:  []byte(name),
						Tags:   map[string]slices.String{"json": append(slices.String(nil), tags...)},
					})
					if cnt[f.RType] > 1 {
						res.Fields = append(res.Fields, res.Fields[len(res.Fields)-1])
					}
					continue
				}
				nxc[ft]++
				if nxc[ft] == 1 {
					nxt = append(nxt, RField{
						RType: ft,
						Name: ft.Name(),
						Index: index,
					})
				}
			}

		}
	}

	for i,f := range res.Fields {
		res.NameIndex[f.Name]=i
	}
	return res

}


*/