[WIP] Initial commit
This commit is contained in:
eleksir
346
vendor/github.com/hjson/hjson-go/v4/structs.go
generated
vendored
Normal file
346
vendor/github.com/hjson/hjson-go/v4/structs.go
generated
vendored
Normal file
@@ -0,0 +1,346 @@
|
||||
package hjson
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type fieldInfo struct {
|
||||
field reflect.Value
|
||||
name string
|
||||
comment string
|
||||
}
|
||||
|
||||
type structFieldInfo struct {
|
||||
name string
|
||||
tagged bool
|
||||
comment string
|
||||
omitEmpty bool
|
||||
indexPath []int
|
||||
}
|
||||
|
||||
// Use lower key name as key. Values are arrays in case some fields only differ
|
||||
// by upper/lower case.
|
||||
type structFieldMap map[string][]structFieldInfo
|
||||
|
||||
func (s structFieldMap) insert(sfi structFieldInfo) {
|
||||
key := strings.ToLower(sfi.name)
|
||||
s[key] = append(s[key], sfi)
|
||||
}
|
||||
|
||||
func (s structFieldMap) getField(name string) (structFieldInfo, bool) {
|
||||
key := strings.ToLower(name)
|
||||
if arr, ok := s[key]; ok {
|
||||
for _, elem := range arr {
|
||||
if elem.name == name {
|
||||
return elem, true
|
||||
}
|
||||
}
|
||||
return arr[0], true
|
||||
}
|
||||
|
||||
return structFieldInfo{}, false
|
||||
}
|
||||
|
||||
// dominantField looks through the fields, all of which are known to
|
||||
// have the same name, to find the single field that dominates the
|
||||
// others using Go's embedding rules, modified by the presence of
|
||||
// JSON tags. If there are multiple top-level fields, the boolean
|
||||
// will be false: This condition is an error in Go and we skip all
|
||||
// the fields.
|
||||
func dominantField(fields []structFieldInfo) (structFieldInfo, bool) {
|
||||
// The fields are sorted in increasing index-length order, then by presence of tag.
|
||||
// That means that the first field is the dominant one. We need only check
|
||||
// for error cases: two fields at top level, either both tagged or neither tagged.
|
||||
if len(fields) > 1 && len(fields[0].indexPath) == len(fields[1].indexPath) && fields[0].tagged == fields[1].tagged {
|
||||
return structFieldInfo{}, false
|
||||
}
|
||||
return fields[0], true
|
||||
}
|
||||
|
||||
// byIndex sorts by index sequence.
|
||||
type byIndex []structFieldInfo
|
||||
|
||||
func (x byIndex) Len() int { return len(x) }
|
||||
|
||||
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
||||
|
||||
func (x byIndex) Less(i, j int) bool {
|
||||
for k, xik := range x[i].indexPath {
|
||||
if k >= len(x[j].indexPath) {
|
||||
return false
|
||||
}
|
||||
if xik != x[j].indexPath[k] {
|
||||
return xik < x[j].indexPath[k]
|
||||
}
|
||||
}
|
||||
return len(x[i].indexPath) < len(x[j].indexPath)
|
||||
}
|
||||
|
||||
func getStructFieldInfo(rootType reflect.Type) []structFieldInfo {
|
||||
type structInfo struct {
|
||||
typ reflect.Type
|
||||
indexPath []int
|
||||
}
|
||||
var sfis []structFieldInfo
|
||||
structsToInvestigate := []structInfo{structInfo{typ: rootType}}
|
||||
// Struct types already visited at an earlier depth.
|
||||
visited := map[reflect.Type]bool{}
|
||||
// Count the number of specific struct types on a specific depth.
|
||||
typeDepthCount := map[reflect.Type]int{}
|
||||
|
||||
for len(structsToInvestigate) > 0 {
|
||||
curStructs := structsToInvestigate
|
||||
structsToInvestigate = []structInfo{}
|
||||
curTDC := typeDepthCount
|
||||
typeDepthCount = map[reflect.Type]int{}
|
||||
|
||||
for _, curStruct := range curStructs {
|
||||
if visited[curStruct.typ] {
|
||||
// The struct type has already appeared on an earlier depth. Fields on
|
||||
// an earlier depth always have precedence over fields with identical
|
||||
// name on a later depth, so no point in investigating this type again.
|
||||
continue
|
||||
}
|
||||
visited[curStruct.typ] = true
|
||||
|
||||
for i := 0; i < curStruct.typ.NumField(); i++ {
|
||||
sf := curStruct.typ.Field(i)
|
||||
|
||||
if sf.Anonymous {
|
||||
t := sf.Type
|
||||
if t.Kind() == reflect.Ptr {
|
||||
t = t.Elem()
|
||||
}
|
||||
// If the field is not exported and not a struct.
|
||||
if sf.PkgPath != "" && t.Kind() != reflect.Struct {
|
||||
// Ignore embedded fields of unexported non-struct types.
|
||||
continue
|
||||
}
|
||||
// Do not ignore embedded fields of unexported struct types
|
||||
// since they may have exported fields.
|
||||
} else if sf.PkgPath != "" {
|
||||
// Ignore unexported non-embedded fields.
|
||||
continue
|
||||
}
|
||||
|
||||
jsonTag := sf.Tag.Get("json")
|
||||
if jsonTag == "-" {
|
||||
continue
|
||||
}
|
||||
|
||||
sfi := structFieldInfo{
|
||||
name: sf.Name,
|
||||
comment: sf.Tag.Get("comment"),
|
||||
}
|
||||
|
||||
splits := strings.Split(jsonTag, ",")
|
||||
if splits[0] != "" {
|
||||
sfi.name = splits[0]
|
||||
sfi.tagged = true
|
||||
}
|
||||
if len(splits) > 1 {
|
||||
for _, opt := range splits[1:] {
|
||||
if opt == "omitempty" {
|
||||
sfi.omitEmpty = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sfi.indexPath = make([]int, len(curStruct.indexPath)+1)
|
||||
copy(sfi.indexPath, curStruct.indexPath)
|
||||
sfi.indexPath[len(curStruct.indexPath)] = i
|
||||
|
||||
ft := sf.Type
|
||||
if ft.Name() == "" && ft.Kind() == reflect.Ptr {
|
||||
// Follow pointer.
|
||||
ft = ft.Elem()
|
||||
}
|
||||
|
||||
// If the current field should be included.
|
||||
if sfi.tagged || !sf.Anonymous || ft.Kind() != reflect.Struct {
|
||||
sfis = append(sfis, sfi)
|
||||
if curTDC[curStruct.typ] > 1 {
|
||||
// If there were multiple instances, add a second,
|
||||
// so that the annihilation code will see a duplicate.
|
||||
// It only cares about the distinction between 1 or 2,
|
||||
// so don't bother generating any more copies.
|
||||
sfis = append(sfis, sfi)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
// Record new anonymous struct to explore in next round.
|
||||
typeDepthCount[ft]++
|
||||
if typeDepthCount[ft] == 1 {
|
||||
structsToInvestigate = append(structsToInvestigate, structInfo{
|
||||
typ: ft,
|
||||
indexPath: sfi.indexPath,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sort.Slice(sfis, func(i, j int) bool {
|
||||
// sort field by name, breaking ties with depth, then
|
||||
// breaking ties with "name came from json tag", then
|
||||
// breaking ties with index sequence.
|
||||
if sfis[i].name != sfis[j].name {
|
||||
return sfis[i].name < sfis[j].name
|
||||
}
|
||||
if len(sfis[i].indexPath) != len(sfis[j].indexPath) {
|
||||
return len(sfis[i].indexPath) < len(sfis[j].indexPath)
|
||||
}
|
||||
if sfis[i].tagged != sfis[j].tagged {
|
||||
return sfis[i].tagged
|
||||
}
|
||||
return byIndex(sfis).Less(i, j)
|
||||
})
|
||||
|
||||
// Delete all fields that are hidden by the Go rules for embedded fields,
|
||||
// except that fields with JSON tags are promoted.
|
||||
|
||||
// The fields are sorted in primary order of name, secondary order
|
||||
// of field index length. Loop over names; for each name, delete
|
||||
// hidden fields by choosing the one dominant field that survives.
|
||||
out := sfis[:0]
|
||||
for advance, i := 0, 0; i < len(sfis); i += advance {
|
||||
// One iteration per name.
|
||||
// Find the sequence of sfis with the name of this first field.
|
||||
sfi := sfis[i]
|
||||
name := sfi.name
|
||||
for advance = 1; i+advance < len(sfis); advance++ {
|
||||
fj := sfis[i+advance]
|
||||
if fj.name != name {
|
||||
break
|
||||
}
|
||||
}
|
||||
if advance == 1 { // Only one field with this name
|
||||
out = append(out, sfi)
|
||||
continue
|
||||
}
|
||||
dominant, ok := dominantField(sfis[i : i+advance])
|
||||
if ok {
|
||||
out = append(out, dominant)
|
||||
}
|
||||
}
|
||||
|
||||
return out
|
||||
}
|
||||
|
||||
func getStructFieldInfoSlice(rootType reflect.Type) []structFieldInfo {
|
||||
sfis := getStructFieldInfo(rootType)
|
||||
|
||||
sort.Sort(byIndex(sfis))
|
||||
|
||||
return sfis
|
||||
}
|
||||
|
||||
func getStructFieldInfoMap(rootType reflect.Type) structFieldMap {
|
||||
sfis := getStructFieldInfo(rootType)
|
||||
|
||||
out := structFieldMap{}
|
||||
for _, elem := range sfis {
|
||||
out.insert(elem)
|
||||
}
|
||||
|
||||
return out
|
||||
}
|
||||
|
||||
func (e *hjsonEncoder) writeFields(
|
||||
fis []fieldInfo,
|
||||
noIndent bool,
|
||||
separator string,
|
||||
isRootObject bool,
|
||||
isObjElement bool,
|
||||
cm Comments,
|
||||
) error {
|
||||
indent1 := e.indent
|
||||
if !isRootObject || e.EmitRootBraces || len(fis) == 0 {
|
||||
e.bracesIndent(isObjElement, len(fis) == 0, cm, separator)
|
||||
e.WriteString("{" + cm.InsideFirst)
|
||||
|
||||
if len(fis) == 0 {
|
||||
if cm.InsideFirst != "" || cm.InsideLast != "" {
|
||||
e.WriteString(e.Eol)
|
||||
}
|
||||
e.WriteString(cm.InsideLast)
|
||||
if cm.InsideLast != "" {
|
||||
endsInsideComment, endsWithLineFeed := investigateComment(cm.InsideLast)
|
||||
if endsInsideComment {
|
||||
e.writeIndent(e.indent)
|
||||
}
|
||||
if endsWithLineFeed {
|
||||
e.writeIndentNoEOL(e.indent)
|
||||
}
|
||||
} else if cm.InsideFirst != "" {
|
||||
e.writeIndentNoEOL(e.indent)
|
||||
}
|
||||
e.WriteString("}")
|
||||
return nil
|
||||
}
|
||||
|
||||
e.indent++
|
||||
} else {
|
||||
e.WriteString(cm.InsideFirst)
|
||||
}
|
||||
|
||||
// Join all of the member texts together, separated with newlines
|
||||
var elemCm Comments
|
||||
for i, fi := range fis {
|
||||
var elem reflect.Value
|
||||
elem, elemCm = e.unpackNode(fi.field, elemCm)
|
||||
if i > 0 || !isRootObject || e.EmitRootBraces {
|
||||
e.WriteString(e.Eol)
|
||||
}
|
||||
if len(fi.comment) > 0 {
|
||||
for _, line := range strings.Split(fi.comment, e.Eol) {
|
||||
e.writeIndentNoEOL(e.indent)
|
||||
e.WriteString(fmt.Sprintf("# %s\n", line))
|
||||
}
|
||||
}
|
||||
if elemCm.Before == "" {
|
||||
e.writeIndentNoEOL(e.indent)
|
||||
} else {
|
||||
e.WriteString(elemCm.Before)
|
||||
}
|
||||
e.WriteString(e.quoteName(fi.name))
|
||||
e.WriteString(":")
|
||||
e.WriteString(elemCm.Key)
|
||||
|
||||
if err := e.str(elem, false, " ", false, true, elemCm); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if len(fi.comment) > 0 && i < len(fis)-1 {
|
||||
e.WriteString(e.Eol)
|
||||
}
|
||||
|
||||
e.WriteString(elemCm.After)
|
||||
}
|
||||
|
||||
if cm.InsideLast != "" {
|
||||
e.WriteString(e.Eol + cm.InsideLast)
|
||||
}
|
||||
|
||||
if !isRootObject || e.EmitRootBraces {
|
||||
if cm.InsideLast == "" {
|
||||
e.writeIndent(indent1)
|
||||
} else {
|
||||
endsInsideComment, endsWithLineFeed := investigateComment(cm.InsideLast)
|
||||
if endsInsideComment {
|
||||
e.writeIndent(indent1)
|
||||
} else if endsWithLineFeed {
|
||||
e.writeIndentNoEOL(indent1)
|
||||
}
|
||||
}
|
||||
e.WriteString("}")
|
||||
}
|
||||
|
||||
e.indent = indent1
|
||||
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user