github.com/junaozun/protoc-gen-go-clone@v0.0.0-20231229025521-89199567f720/plugin/clone/gen_clone.go (about)

     1  package clone
     2  
     3  import (
     4  	"sort"
     5  	"strings"
     6  
     7  	"github.com/junaozun/protoc-gen-go-clone/pkg/tmpl"
     8  )
     9  
    10  type genClone struct {
    11  	parseFd        *parseFd
    12  	annotationFlag map[string]*announceObj // 注释对象名->announceObj
    13  	funcWayStore   map[string]IFieldDesc   // funcName->IFieldDesc
    14  }
    15  
    16  type announceObj struct {
    17  	objPkgName string       // 注释对象所在包名
    18  	genPkgName string       // 最终生成文件所在包名
    19  	allRefers  []*referObjs // 对象直接或间接引用的所有对象
    20  }
    21  
    22  // 哪个包下哪个文件中的对象
    23  type referObjs struct {
    24  	objName     string // 对象名
    25  	valuePrefix string // 对象前缀
    26  	parentObj   string
    27  	finalValue  string
    28  }
    29  
    30  type convertTemps struct {
    31  	key   string
    32  	value IFieldDesc
    33  }
    34  
    35  func NewGenClone(parseFd *parseFd) *genClone {
    36  	return &genClone{
    37  		parseFd:        parseFd,
    38  		annotationFlag: make(map[string]*announceObj),
    39  		funcWayStore:   make(map[string]IFieldDesc),
    40  	}
    41  }
    42  
    43  func (g *genClone) ContainString(imp string) bool {
    44  	for _, v := range g.annotationFlag {
    45  		for _, m := range v.allRefers {
    46  			if m.valuePrefix == imp {
    47  				return true
    48  			}
    49  		}
    50  	}
    51  	return false
    52  }
    53  
    54  func (g *genClone) GenClone(pkgName string) {
    55  	for k, v := range g.parseFd.annObject {
    56  		for _, vv := range v {
    57  			g.annotationFlag[vv] = &announceObj{
    58  				objPkgName: k,
    59  				genPkgName: pkgName,
    60  			}
    61  		}
    62  	}
    63  
    64  	for _, fileInfo := range g.parseFd.sourceFileMap {
    65  		if !fileInfo.isSourceFile {
    66  			continue
    67  		}
    68  		for structName, allFields := range fileInfo.allObjects {
    69  			g.parseObject(structName, allFields)
    70  		}
    71  	}
    72  
    73  	g.genParentClone()
    74  	g.genSonClone()
    75  	g.genWayClone()
    76  }
    77  
    78  func (g *genClone) parseObject(structName string, allFields []IFieldDesc) {
    79  	// 解析出这个结构体直接引用和间接引用的所有对象
    80  	for _, v := range allFields {
    81  		// 过滤非对象字段
    82  		if v.isValueBase() {
    83  			continue
    84  		}
    85  		// 过滤一下未注释的对象
    86  		mm, ok := g.annotationFlag[structName]
    87  		if !ok {
    88  			return
    89  		}
    90  		// 过滤一下已经存在的对象名
    91  		if containString(mm.allRefers, v.getValueType(), v.getValuePrefix()) {
    92  			continue
    93  		}
    94  
    95  		prefix := v.getValuePrefix()
    96  		g.annotationFlag[structName].allRefers = append(g.annotationFlag[structName].allRefers, &referObjs{
    97  			objName:     v.getValueType(),
    98  			valuePrefix: prefix,
    99  			parentObj:   structName,
   100  			finalValue:  v.getFinalVal(),
   101  		})
   102  		// 查找子对象
   103  		rs, _ := g.findObjAllFields(prefix, v.getValueType())
   104  		g.parseObject(structName, rs)
   105  	}
   106  }
   107  
   108  func (g *genClone) findObjAllFields(valuePrefix, valueType string) ([]IFieldDesc, bool) {
   109  	for _, fileMsg := range g.parseFd.sourceFileMap {
   110  		if fileMsg.packageName != valuePrefix {
   111  			continue
   112  		}
   113  		obj, ok := fileMsg.allObjects[strings.Title(valueType)]
   114  		if !ok {
   115  			continue
   116  		}
   117  		return obj, fileMsg.isProto3
   118  	}
   119  	panic("not findObjAllFields :" + valuePrefix + valueType)
   120  }
   121  
   122  type tplTemp struct {
   123  	FuncName []string
   124  	ObName   string
   125  	Fields   map[string]string
   126  }
   127  
   128  type genTemp struct {
   129  	genPkgName  string
   130  	isProto3    bool
   131  	objName     string
   132  	finalValue  string
   133  	valuePrefix string
   134  	parentObj   string
   135  	fDesc       []IFieldDesc
   136  }
   137  
   138  func (g *genTemp) isNeedPrefix(prefix string) bool {
   139  	return g.genPkgName != prefix
   140  }
   141  
   142  // generate export way
   143  func (g *genClone) genParentClone() {
   144  	parents := make([]*genTemp, 0, 10)
   145  	for k, v := range g.annotationFlag {
   146  		allFields, isProto3 := g.findObjAllFields(v.objPkgName, k)
   147  		parents = append(parents, &genTemp{
   148  			genPkgName: v.genPkgName,
   149  			parentObj:  k,
   150  			isProto3:   isProto3,
   151  			objName:    k,
   152  			fDesc:      allFields,
   153  		})
   154  	}
   155  	sort.Slice(parents, func(i, j int) bool {
   156  		return parents[i].objName < parents[j].objName
   157  	})
   158  	for _, par := range parents {
   159  		input := &tplTemp{
   160  			ObName: par.objName,
   161  			Fields: make(map[string]string),
   162  		}
   163  		for _, v := range par.fDesc {
   164  			filedName, value := v.addFuncWay(par, g.funcWayStore)
   165  			input.Fields[filedName] = value
   166  		}
   167  		b, err := tmpl.Render(tempParent, input)
   168  		if err != nil {
   169  			g.parseFd.gen.Error(err)
   170  		}
   171  		g.parseFd.gen.P(string(b))
   172  	}
   173  }
   174  
   175  // return fieldName,value
   176  func (m *mapEntry) addFuncWay(temp *genTemp, funcWay map[string]IFieldDesc) (string, string) {
   177  	fn := strings.Title(m.fieldName)
   178  	strings.Split(fn, "_")
   179  	value := strings.Title(m.valueType)
   180  	if !m.isBaseType {
   181  		value = m.valuePrefix + "_" + value
   182  	}
   183  	m.needPrefix = temp.isNeedPrefix(m.valuePrefix)
   184  	funcName := "clone_" + strings.Title(temp.parentObj) + "_Map_" + m.keyType + "_" + value
   185  	if _, ok := funcWay[funcName]; !ok {
   186  		funcWay[funcName] = m
   187  	}
   188  	return fn, funcName + "(in." + fn + ")"
   189  }
   190  
   191  func (a *array) addFuncWay(temp *genTemp, funcWay map[string]IFieldDesc) (string, string) {
   192  	fn := strings.Title(a.fieldName)
   193  
   194  	if a.isBaseType {
   195  		return fn, "append(in." + fn + "[:0:0], in." + fn + "...)"
   196  	}
   197  	funcName := "clone_" + strings.Title(temp.parentObj) + "_Array_" + a.valuePrefix + "_" + strings.Title(a.valueType)
   198  	a.needPrefix = temp.isNeedPrefix(a.valuePrefix)
   199  	if _, ok := funcWay[funcName]; !ok {
   200  		funcWay[funcName] = a
   201  	}
   202  	return fn, funcName + "(in." + fn + ")"
   203  }
   204  
   205  func (e *enum) addFuncWay(temp *genTemp, funcWay map[string]IFieldDesc) (string, string) {
   206  	fn := strings.Title(e.fieldName)
   207  	funcName := "clone" + "Enum" + temp.parentObj + e.valueType
   208  	if temp.isProto3 {
   209  		return fn, "in." + fn
   210  	}
   211  	e.needPrefix = temp.isNeedPrefix(e.valuePrefix)
   212  	// pb2需要对enum生成clone方法
   213  	if _, ok := funcWay[funcName]; !ok {
   214  		funcWay[funcName] = e
   215  	}
   216  	return fn, funcName + "(in." + fn + ")"
   217  }
   218  
   219  func (m *message) addFuncWay(temp *genTemp, funcWay map[string]IFieldDesc) (string, string) {
   220  	fn := strings.Title(m.fieldName)
   221  	m.needPrefix = temp.isNeedPrefix(m.valuePrefix)
   222  	funcName := "clone_" + strings.Title(temp.parentObj) + "_" + m.valuePrefix + "_" + strings.Title(m.valueType)
   223  	return fn, funcName + "(in." + fn + ")"
   224  }
   225  
   226  func (b *base) addFuncWay(temp *genTemp, funcWay map[string]IFieldDesc) (string, string) {
   227  	fn := strings.Title(b.fieldName)
   228  	if temp.isProto3 {
   229  		return fn, "in." + fn
   230  	}
   231  	funcName := "clone" + strings.Title(b.valueType) + "Pointer"
   232  	// pb2需要对base生成clone方法
   233  	if _, ok := funcWay[funcName]; !ok {
   234  		funcWay[funcName] = b
   235  	}
   236  	return fn, funcName + "(in." + fn + ")"
   237  }
   238  
   239  // generate no export ways
   240  func (g *genClone) genSonClone() {
   241  	sons := make([]*genTemp, 0, 10000)
   242  	for ob, v := range g.annotationFlag {
   243  		for _, son := range v.allRefers {
   244  			allFields, isProto3 := g.findObjAllFields(son.valuePrefix, son.objName)
   245  			sons = append(sons, &genTemp{
   246  				genPkgName:  v.genPkgName,
   247  				isProto3:    isProto3,
   248  				objName:     son.objName,
   249  				finalValue:  son.finalValue,
   250  				valuePrefix: son.valuePrefix,
   251  				parentObj:   ob,
   252  				fDesc:       allFields,
   253  			})
   254  		}
   255  
   256  	}
   257  	sort.Slice(sons, func(i, j int) bool {
   258  		return sons[i].objName < sons[j].objName
   259  	})
   260  	for _, son := range sons {
   261  		value := strings.Title(son.objName)
   262  		funcName := []string{son.parentObj, son.valuePrefix, strings.Title(son.objName)}
   263  		if son.valuePrefix != son.genPkgName {
   264  			value = son.valuePrefix + "." + value
   265  		}
   266  		if son.finalValue != "" {
   267  			value = son.finalValue
   268  		}
   269  		input := &tplTemp{
   270  			FuncName: funcName,
   271  			ObName:   value,
   272  			Fields:   make(map[string]string),
   273  		}
   274  
   275  		for _, v := range son.fDesc {
   276  			filedName, valueFunc := v.addFuncWay(son, g.funcWayStore)
   277  			input.Fields[filedName] = valueFunc
   278  		}
   279  		b, err := tmpl.Render(tempSon, input)
   280  		if err != nil {
   281  			g.parseFd.gen.Error(err)
   282  		}
   283  		g.parseFd.gen.P(string(b))
   284  	}
   285  }
   286  
   287  func (g *genClone) genWayClone() {
   288  	sortWays := make([]*convertTemps, 0, len(g.funcWayStore))
   289  	for k, v := range g.funcWayStore {
   290  		sortWays = append(sortWays, &convertTemps{
   291  			key:   k,
   292  			value: v,
   293  		})
   294  	}
   295  	sort.Slice(sortWays, func(i, j int) bool {
   296  		return sortWays[i].key < sortWays[j].key
   297  	})
   298  	for _, v := range sortWays {
   299  		b, err := v.value.clone(v.key)
   300  		if err != nil {
   301  			g.parseFd.gen.Error(err)
   302  		}
   303  		g.parseFd.gen.P(string(b))
   304  	}
   305  }
   306  
   307  func (m *mapEntry) clone(funcName string) ([]byte, error) {
   308  	valueType := strings.Title(m.valueType)
   309  	data := map[string]interface{}{
   310  		"funcName": funcName,
   311  		"keyType":  m.keyType,
   312  		"objName":  m.valueType,
   313  	}
   314  	if !m.isBaseType {
   315  		obName := "*" + valueType
   316  		data["sonMsg"] = []string{getParentObjectName(funcName), m.valuePrefix, valueType}
   317  		if m.finalValue != "" {
   318  			obName = "*" + m.finalValue
   319  		}
   320  		data["objName"] = obName
   321  	}
   322  	return tmpl.Render(tempMap, data)
   323  }
   324  
   325  func (a *array) clone(funcName string) ([]byte, error) {
   326  	valueType := strings.Title(a.valueType)
   327  	data := map[string]interface{}{
   328  		"funcName": funcName,
   329  		"objName":  valueType,
   330  		"sonMsg":   []string{getParentObjectName(funcName), a.valuePrefix, valueType},
   331  	}
   332  	if a.finalValue != "" {
   333  		data["objName"] = a.finalValue
   334  	}
   335  	return tmpl.Render(tempArray, data)
   336  }
   337  
   338  func (e *enum) clone(funcName string) ([]byte, error) {
   339  	final := e.valueType
   340  	if e.finalValue != "" {
   341  		final = e.finalValue
   342  	}
   343  	data := map[string]interface{}{
   344  		"funcName": funcName,
   345  		"objName":  final,
   346  	}
   347  	return tmpl.Render(tempEnum, data)
   348  }
   349  
   350  func (m *message) clone(funcName string) ([]byte, error) {
   351  	return nil, nil
   352  }
   353  
   354  func (b *base) clone(funcName string) ([]byte, error) {
   355  	if b.isProto3 {
   356  		return nil, nil
   357  	}
   358  	data := map[string]interface{}{
   359  		"funcName":  funcName,
   360  		"valueType": b.valueType,
   361  	}
   362  	return tmpl.Render(tempBase, data)
   363  }
   364  
   365  func getParentObjectName(funcName string) string {
   366  	return strings.Split(funcName, "_")[1]
   367  }
   368  
   369  func containString(arr []*referObjs, valueType string, valuePrefix string) bool {
   370  	for _, v := range arr {
   371  		if v.objName == valueType && v.valuePrefix == valuePrefix {
   372  			return true
   373  		}
   374  	}
   375  	return false
   376  }