structcache

type CachedFieldInfo struct {
	// WARN:
	//  The [CachedFieldInfoBase] structure cannot be merged with the following [IsField] field into one structure.
	// 	The [IsField] field should be used separately in the [bindStructWithLoopParamsMap] method
	*CachedFieldInfoBase

	// This field is mainly used in the [bindStructWithLoopParamsMap] method.
	// This field is needed when both `fieldName` and `tag` of a field exist in the map.
	// For example:
	// field string `json:"name"`
	// map = {
	//     "field" : "f1",
	//     "name" : "n1",
	// }
	// The `name` should be used here.
	// In the bindStructWithLoopParamsMap method, due to the disorder of `map`, `field` may be traversed first.
	// This field is more about priority, that is, the priority of `name` is higher than that of `field`,
	// even if it has been set before.
	IsField bool
}

type CachedFieldInfoBase struct {
	// FieldIndexes holds the global index number from struct info.
	// The field may belong to an embedded structure, so it is defined here as []int.
	FieldIndexes []int

	// PriorityTagAndFieldName holds the tag value(conv, param, p, c, json) and the field name.
	// PriorityTagAndFieldName contains the field name, which is the last item of slice.
	PriorityTagAndFieldName []string

	// IsCommonInterface marks this field implements common interfaces as:
	// - iUnmarshalValue
	// - iUnmarshalText
	// - iUnmarshalJSON
	// Purpose: reduce the interface asserting cost in runtime.
	IsCommonInterface bool

	// IsCustomConvert marks there custom converting function for this field type.
	IsCustomConvert bool

	// StructField is the type info of this field.
	StructField reflect.StructField

	// OtherSameNameField stores fields with the same name and type or different types of nested structures.
	//
	// For example:
	// type ID struct{
	//     ID1  string
	//     ID2 int
	// }
	// type Card struct{
	//     ID
	//     ID1  uint64
	//     ID2 int64
	// }
	//
	// We will cache each ID1 and ID2 separately,
	// even if their types are different and their indexes are different
	OtherSameNameField []*CachedFieldInfo

	// ConvertFunc is the converting function for this field.
	ConvertFunc func(from any, to reflect.Value)

	// The last fuzzy matching key for this field.
	// The fuzzy matching occurs only if there are no direct tag and field name matching in the params map.
	// TODO If different paramsMaps contain paramKeys in different formats and all hit the same fieldName,
	//      the cached value may be continuously updated.
	// LastFuzzyKey string.
	LastFuzzyKey atomic.Value

	// removeSymbolsFieldName is used for quick fuzzy match for parameter key.
	// removeSymbolsFieldName = utils.RemoveSymbols(fieldName)
	RemoveSymbolsFieldName string
}

type CachedStructInfo struct {

	// All sub attributes field info slice.
	FieldConvertInfos []*CachedFieldInfo
	// contains filtered or unexported fields
}

type CommonConverter struct {
	Int64   func(any interface{}) int64
	Uint64  func(any interface{}) uint64
	String  func(any interface{}) string
	Float32 func(any interface{}) float32
	Float64 func(any interface{}) float64
	Time    func(any interface{}, format ...string) time.Time
	GTime   func(any interface{}, format ...string) *gtime.Time
	Bytes   func(any interface{}) []byte
	Bool    func(any interface{}) bool
}