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 }