From 615262215989c133917bf73b629b283af8738d2f Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Tue, 11 Nov 2025 20:56:18 +0800 Subject: [PATCH 1/8] feat: go impl --- .../helper/helper.go | 6 +- cmd/protoc-gen-go-tableau-loader/messager.go | 2 +- .../ordered_index.go | 197 +++++++++++++----- internal/index/descriptor.go | 5 +- .../protoconf/loader/item_conf.pc.go | 123 +++++++++-- .../protoconf/loader/test_conf.pc.go | 47 +++++ test/proto/item_conf.proto | 6 +- test/proto/test_conf.proto | 1 + 8 files changed, 311 insertions(+), 76 deletions(-) diff --git a/cmd/protoc-gen-go-tableau-loader/helper/helper.go b/cmd/protoc-gen-go-tableau-loader/helper/helper.go index 1a637829..361d7973 100644 --- a/cmd/protoc-gen-go-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-go-tableau-loader/helper/helper.go @@ -100,9 +100,9 @@ func ParseMapKeyType(fd protoreflect.FieldDescriptor) string { // ParseOrderedMapKeyType converts a FieldDescriptor to its treemap key type. // fd must be an ordered type, or a message which can be converted to an ordered type. -func ParseOrderedMapKeyType(fd protoreflect.FieldDescriptor) string { +func ParseOrderedMapKeyType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd protoreflect.FieldDescriptor) string { switch fd.Kind() { - case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.EnumKind: + case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return "int32" case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: return "uint32" @@ -116,6 +116,8 @@ func ParseOrderedMapKeyType(fd protoreflect.FieldDescriptor) string { return "double" case protoreflect.StringKind: return "string" + case protoreflect.EnumKind: + return g.QualifiedGoIdent(FindEnumGoIdent(gen, fd.Enum())) case protoreflect.MessageKind: switch fd.Message().FullName() { case "google.protobuf.Timestamp", "google.protobuf.Duration": diff --git a/cmd/protoc-gen-go-tableau-loader/messager.go b/cmd/protoc-gen-go-tableau-loader/messager.go index add8c904..ec0df01a 100644 --- a/cmd/protoc-gen-go-tableau-loader/messager.go +++ b/cmd/protoc-gen-go-tableau-loader/messager.go @@ -184,7 +184,7 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog genIndexLoader(gen, g, indexDescriptor, messagerName) } if options.NeedGenOrderedIndex(message.Desc, options.LangGO) { - genOrderedIndexLoader(gen, g, indexDescriptor) + genOrderedIndexLoader(gen, g, indexDescriptor, messagerName) } g.P("return nil") g.P("}") diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index.go index bb947e49..b185a9e2 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_index.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_index.go @@ -13,12 +13,42 @@ func genOrderedIndexTypeDef(gen *protogen.Plugin, g *protogen.GeneratedFile, des g.P("// OrderedIndex types.") for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { for _, index := range levelMessage.OrderedIndexes { - // single-column index - field := index.ColFields[0] // just take first field - g.P("// OrderedIndex: ", index.Index) - mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) - keyType := helper.ParseOrderedMapKeyType(field.FD) - g.P("type ", mapType, " = ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]") + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + g.P("// OrderedIndex: ", index.Index) + mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) + keyType := helper.ParseOrderedMapKeyType(gen, g, field.FD) + g.P("type ", mapType, " = ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]") + } else { + // multi-column index + g.P("// OrderedIndex: ", index.Index) + keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) + mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) + + // generate key struct + // KeyType must be comparable, refer https://go.dev/blog/maps + g.P("type ", keyType, " struct {") + for _, field := range index.ColFields { + g.P(helper.ParseIndexFieldNameAsKeyStructFieldName(gen, field.FD), " ", helper.ParseOrderedMapKeyType(gen, g, field.FD)) + } + g.P("}") + g.P() + g.P("func (x ", keyType, ") Less(other ", keyType, ") bool {") + for i, field := range index.ColFields { + fieldName := helper.ParseIndexFieldNameAsKeyStructFieldName(gen, field.FD) + if i == len(index.ColFields)-1 { + g.P("return x.", fieldName, " < other.", fieldName) + } else { + g.P("if x.", fieldName, " != other.", fieldName, " {") + g.P("return x.", fieldName, " < other.", fieldName) + g.P("}") + } + } + g.P("}") + g.P() + g.P("type ", mapType, " = ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]") + } g.P() } } @@ -34,21 +64,26 @@ func genOrderedIndexField(g *protogen.GeneratedFile, descriptor *index.IndexDesc } } -func genOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { +func genOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { g.P("// OrderedIndex init.") for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { for _, index := range levelMessage.OrderedIndexes { field := index.ColFields[0] // just take first field indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - keyType := helper.ParseOrderedMapKeyType(field.FD) - g.P("x.", indexContainerName, " = ", treeMapPackage.Ident("New"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]()") + if len(index.ColFields) == 1 { + keyType := helper.ParseOrderedMapKeyType(gen, g, field.FD) + g.P("x.", indexContainerName, " = ", treeMapPackage.Ident("New"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]()") + } else { + keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) + g.P("x.", indexContainerName, " = ", treeMapPackage.Ident("New2"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]()") + } } } parentDataName := "x.data" depth := 1 for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { for _, index := range levelMessage.OrderedIndexes { - genOneOrderedIndexLoader(gen, g, depth, index, parentDataName) + genOneOrderedIndexLoader(gen, g, depth, index, parentDataName, messagerName) } itemName := fmt.Sprintf("item%d", depth) if levelMessage.FD == nil { @@ -64,63 +99,105 @@ func genOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, desc for i := depth - 1; i > 0; i-- { g.P("}") } - genOrderedIndexSorter(gen, g, descriptor) + genOrderedIndexSorter(gen, g, descriptor, messagerName) } func genOneOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, depth int, index *index.LevelIndex, - parentDataName string) { + parentDataName string, messagerName string) { indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" g.P("{") g.P("// OrderedIndex: ", index.Index) - // single-column index - field := index.ColFields[0] // just take the first field - if field.FD.IsList() { - itemName := fmt.Sprintf("item%d", depth) - fieldName := "" - suffix := "" - for i, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { - switch leveledFd.Message().FullName() { - case "google.protobuf.Timestamp", "google.protobuf.Duration": - suffix = ".GetSeconds()" - default: - } - } + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take the first field + if field.FD.IsList() { + itemName := fmt.Sprintf("item%d", depth) + fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) + g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + g.P("key := ", itemName, suffix) + g.P("value, _ := x.", indexContainerName, ".Get(key)") + g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") + g.P("}") + } else { + fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) + g.P("key := ", parentDataName, fieldName, suffix) + g.P("value, _ := x.", indexContainerName, ".Get(key)") + g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") } - g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - g.P("key := ", itemName, suffix) - g.P("value, _ := x.", indexContainerName, ".Get(key)") - g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") - g.P("}") } else { - fieldName := "" - suffix := "" - for i, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { - switch leveledFd.Message().FullName() { - case "google.protobuf.Timestamp", "google.protobuf.Duration": - suffix = ".GetSeconds()" - default: - } + // multi-column index + generateOneMulticolumnOrderedIndex(gen, g, depth, index, parentDataName, messagerName, nil) + } + g.P("}") +} + +func parseOrderedIndexKeyFieldNameAndSuffix(gen *protogen.Plugin, field *index.LevelField) (string, string) { + var fieldName, suffix string + for i, leveledFd := range field.LeveledFDList { + fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" + if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { + switch leveledFd.Message().FullName() { + case "google.protobuf.Timestamp", "google.protobuf.Duration": + suffix = ".GetSeconds()" + default: + } + } + } + return fieldName, suffix +} + +func generateOneMulticolumnOrderedIndex(gen *protogen.Plugin, g *protogen.GeneratedFile, + depth int, index *index.LevelIndex, parentDataName string, messagerName string, keys []string) []string { + cursor := len(keys) + if cursor >= len(index.ColFields) { + var keyParams string + for i, key := range keys { + keyParams += key + if i != len(keys)-1 { + keyParams += ", " } } - g.P("key := ", parentDataName, fieldName, suffix) + keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) + indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" + g.P("key := ", keyType, " {", keyParams, "}") g.P("value, _ := x.", indexContainerName, ".Get(key)") g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") + return keys } - - g.P("}") + field := index.ColFields[cursor] + if field.FD.IsList() { + itemName := fmt.Sprintf("indexItem%d", cursor) + fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) + g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + key := itemName + suffix + keys = append(keys, key) // fixme:keys + keys = generateOneMulticolumnOrderedIndex(gen, g, depth+1, index, parentDataName, messagerName, keys) + g.P("}") + } else { + fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) + key := parentDataName + fieldName + suffix + keys = append(keys, key) + keys = generateOneMulticolumnOrderedIndex(gen, g, depth, index, parentDataName, messagerName, keys) + } + return keys } -func genOrderedIndexSorter(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { +func genOrderedIndexSorter(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { for _, index := range levelMessage.OrderedIndexes { indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" if len(index.SortedColFields) != 0 { g.P("// OrderedIndex(sort): ", index.Index) - g.P("x.", indexContainerName, ".Range(func(key int64, item []*", helper.FindMessageGoIdent(gen, index.MD), ") bool {") + var keyType string + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + keyType = helper.ParseOrderedMapKeyType(gen, g, field.FD) + } else { + // multi-column index + keyType = fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) + } + g.P("x.", indexContainerName, ".Range(func(key ", keyType, ", item []*", helper.FindMessageGoIdent(gen, index.MD), ") bool {") g.P(sortPackage.Ident("Slice"), "(item, func(i, j int) bool {") for i, field := range index.SortedColFields { fieldName := "" @@ -159,22 +236,30 @@ func genOrderedIndexFinders(gen *protogen.Plugin, g *protogen.GeneratedFile, des g.P("}") g.P() - // single-column index - field := index.ColFields[0] // just take first field - keyType := helper.ParseOrderedMapKeyType(field.FD) - keyName := helper.ParseIndexFieldNameAsFuncParam(gen, field.FD) + var keys []helper.MapKey + for _, field := range index.ColFields { + keys = append(keys, helper.MapKey{ + Type: helper.ParseOrderedMapKeyType(gen, g, field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(gen, field.FD), + }) + } g.P("// Find", index.Name(), " finds a slice of all values of the given key.") - g.P("func (x *", messagerName, ") Find", index.Name(), "(", keyName, " ", keyType, ") []*", helper.FindMessageGoIdent(gen, index.MD), " {") - g.P("val, _ := x.", indexContainerName, ".Get(", keyName, ")") - g.P("return val") + g.P("func (x *", messagerName, ") Find", index.Name(), "(", helper.GenGetParams(keys), ") []*", helper.FindMessageGoIdent(gen, index.MD), " {") + if len(index.ColFields) == 1 { + g.P("val, _ := x.", indexContainerName, ".Get(", helper.GenGetArguments(keys), ")") + g.P("return val") + } else { + g.P("val, _ := x.", indexContainerName, ".Get(", fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()), "{", helper.GenGetArguments(keys), "})") + g.P("return val") + } g.P("}") g.P() g.P("// FindFirst", index.Name(), " finds the first value of the given key,") g.P("// or nil if no value found.") - g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", keyName, " ", keyType, ") *", helper.FindMessageGoIdent(gen, index.MD), " {") - g.P("val := x.Find", index.Name(), "(", keyName, ")") + g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", helper.GenGetParams(keys), ") *", helper.FindMessageGoIdent(gen, index.MD), " {") + g.P("val := x.Find", index.Name(), "(", helper.GenGetArguments(keys), ")") g.P("if len(val) > 0 {") g.P("return val[0]") g.P("}") diff --git a/internal/index/descriptor.go b/internal/index/descriptor.go index f6fb4eaf..d5e808d6 100644 --- a/internal/index/descriptor.go +++ b/internal/index/descriptor.go @@ -107,10 +107,7 @@ func parseRecursively(index *Index, prefix string, md protoreflect.MessageDescri SortedColFields: sortedColFields, } if ordered { - if len(colFields) == 1 { - // only support one column ordered index - levelMessage.OrderedIndexes = append(levelMessage.OrderedIndexes, levelIndex) - } + levelMessage.OrderedIndexes = append(levelMessage.OrderedIndexes, levelIndex) } else { levelMessage.Indexes = append(levelMessage.Indexes, levelIndex) } diff --git a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go index 1cecc5e9..991779b8 100644 --- a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go @@ -62,6 +62,25 @@ type ItemConf_Index_ItemPathFriendIDMap = map[uint32][]*protoconf.ItemConf_Item // Index: UseEffectType@UseEffectType type ItemConf_Index_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf.ItemConf_Item +// OrderedIndex types. +// OrderedIndex: ExtType@ExtType +type ItemConf_OrderedIndex_ExtTypeMap = treemap.TreeMap[protoconf.FruitType, []*protoconf.ItemConf_Item] + +// OrderedIndex: (Param,ExtType)@ParamExtType +type ItemConf_OrderedIndex_ParamExtTypeKey struct { + Param int32 + ExtType protoconf.FruitType +} + +func (x ItemConf_OrderedIndex_ParamExtTypeKey) Less(other ItemConf_OrderedIndex_ParamExtTypeKey) bool { + if x.Param != other.Param { + return x.Param < other.Param + } + return x.ExtType < other.ExtType +} + +type ItemConf_OrderedIndex_ParamExtTypeMap = treemap.TreeMap[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item] + // ItemConf is a wrapper around protobuf message: protoconf.ItemConf. // // It is designed for three goals: @@ -71,18 +90,20 @@ type ItemConf_Index_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf // 3. Extensibility: Map, OrdererdMap, Index, OrderedIndex... type ItemConf struct { UnimplementedMessager - data, originalData *protoconf.ItemConf - orderedMap *ProtoconfItemConfItemMap_OrderedMap - indexItemMap ItemConf_Index_ItemMap - indexItemInfoMap ItemConf_Index_ItemInfoMap - indexItemDefaultInfoMap ItemConf_Index_ItemDefaultInfoMap - indexItemExtInfoMap ItemConf_Index_ItemExtInfoMap - indexAwardItemMap ItemConf_Index_AwardItemMap - indexSpecialItemMap ItemConf_Index_SpecialItemMap - indexItemPathDirMap ItemConf_Index_ItemPathDirMap - indexItemPathNameMap ItemConf_Index_ItemPathNameMap - indexItemPathFriendIdMap ItemConf_Index_ItemPathFriendIDMap - indexUseEffectTypeMap ItemConf_Index_UseEffectTypeMap + data, originalData *protoconf.ItemConf + orderedMap *ProtoconfItemConfItemMap_OrderedMap + indexItemMap ItemConf_Index_ItemMap + indexItemInfoMap ItemConf_Index_ItemInfoMap + indexItemDefaultInfoMap ItemConf_Index_ItemDefaultInfoMap + indexItemExtInfoMap ItemConf_Index_ItemExtInfoMap + indexAwardItemMap ItemConf_Index_AwardItemMap + indexSpecialItemMap ItemConf_Index_SpecialItemMap + indexItemPathDirMap ItemConf_Index_ItemPathDirMap + indexItemPathNameMap ItemConf_Index_ItemPathNameMap + indexItemPathFriendIdMap ItemConf_Index_ItemPathFriendIDMap + indexUseEffectTypeMap ItemConf_Index_UseEffectTypeMap + orderedIndexExtTypeMap *ItemConf_OrderedIndex_ExtTypeMap + orderedIndexParamExtTypeMap *ItemConf_OrderedIndex_ParamExtTypeMap } // Name returns the ItemConf's message name. @@ -238,6 +259,36 @@ func (x *ItemConf) processAfterLoad() error { return item[i].GetUseEffect().GetType() < item[j].GetUseEffect().GetType() }) } + // OrderedIndex init. + x.orderedIndexExtTypeMap = treemap.New[protoconf.FruitType, []*protoconf.ItemConf_Item]() + x.orderedIndexParamExtTypeMap = treemap.New2[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item]() + for _, item1 := range x.data.GetItemMap() { + { + // OrderedIndex: ExtType@ExtType + for _, item2 := range item1.GetExtTypeList() { + key := item2 + value, _ := x.orderedIndexExtTypeMap.Get(key) + x.orderedIndexExtTypeMap.Put(key, append(value, item1)) + } + } + { + // OrderedIndex: (Param,ExtType)@ParamExtType + for _, indexItem0 := range item1.GetParamList() { + for _, indexItem1 := range item1.GetExtTypeList() { + key := ItemConf_OrderedIndex_ParamExtTypeKey{indexItem0, indexItem1} + value, _ := x.orderedIndexParamExtTypeMap.Get(key) + x.orderedIndexParamExtTypeMap.Put(key, append(value, item1)) + } + } + } + } + // OrderedIndex(sort): (Param,ExtType)@ParamExtType + x.orderedIndexParamExtTypeMap.Range(func(key ItemConf_OrderedIndex_ParamExtTypeKey, item []*protoconf.ItemConf_Item) bool { + sort.Slice(item, func(i, j int) bool { + return item[i].GetId() < item[j].GetId() + }) + return true + }) return nil } @@ -487,6 +538,54 @@ func (x *ItemConf) FindFirstUseEffectType(type_ protoconf.UseEffect_Type) *proto return nil } +// OrderedIndex: ExtType@ExtType + +// FindExtTypeMap finds the ordered index (ExtType@ExtType) to value (protoconf.ItemConf_Item) treemap. +// One key may correspond to multiple values, which are contained by a slice. +func (x *ItemConf) FindExtTypeMap() *ItemConf_OrderedIndex_ExtTypeMap { + return x.orderedIndexExtTypeMap +} + +// FindExtType finds a slice of all values of the given key. +func (x *ItemConf) FindExtType(extType protoconf.FruitType) []*protoconf.ItemConf_Item { + val, _ := x.orderedIndexExtTypeMap.Get(extType) + return val +} + +// FindFirstExtType finds the first value of the given key, +// or nil if no value found. +func (x *ItemConf) FindFirstExtType(extType protoconf.FruitType) *protoconf.ItemConf_Item { + val := x.FindExtType(extType) + if len(val) > 0 { + return val[0] + } + return nil +} + +// OrderedIndex: (Param,ExtType)@ParamExtType + +// FindParamExtTypeMap finds the ordered index ((Param,ExtType)@ParamExtType) to value (protoconf.ItemConf_Item) treemap. +// One key may correspond to multiple values, which are contained by a slice. +func (x *ItemConf) FindParamExtTypeMap() *ItemConf_OrderedIndex_ParamExtTypeMap { + return x.orderedIndexParamExtTypeMap +} + +// FindParamExtType finds a slice of all values of the given key. +func (x *ItemConf) FindParamExtType(param int32, extType protoconf.FruitType) []*protoconf.ItemConf_Item { + val, _ := x.orderedIndexParamExtTypeMap.Get(ItemConf_OrderedIndex_ParamExtTypeKey{param, extType}) + return val +} + +// FindFirstParamExtType finds the first value of the given key, +// or nil if no value found. +func (x *ItemConf) FindFirstParamExtType(param int32, extType protoconf.FruitType) *protoconf.ItemConf_Item { + val := x.FindParamExtType(param, extType) + if len(val) > 0 { + return val[0] + } + return nil +} + func init() { Register(func() Messager { return new(ItemConf) diff --git a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go index c5ae05d9..c8f02c1a 100644 --- a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go @@ -573,6 +573,21 @@ type TaskConf_OrderedIndex_TaskExpiryMap = treemap.TreeMap[int64, []*protoconf.T // OrderedIndex: Expiry@SortedTaskExpiry type TaskConf_OrderedIndex_SortedTaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +// OrderedIndex: (Expiry,ActivityID)@ActivityExpiry +type TaskConf_OrderedIndex_ActivityExpiryKey struct { + Expiry int64 + ActivityId int64 +} + +func (x TaskConf_OrderedIndex_ActivityExpiryKey) Less(other TaskConf_OrderedIndex_ActivityExpiryKey) bool { + if x.Expiry != other.Expiry { + return x.Expiry < other.Expiry + } + return x.ActivityId < other.ActivityId +} + +type TaskConf_OrderedIndex_ActivityExpiryMap = treemap.TreeMap[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task] + // TaskConf is a wrapper around protobuf message: protoconf.TaskConf. // // It is designed for three goals: @@ -587,6 +602,7 @@ type TaskConf struct { orderedIndexOrderedTaskMap *TaskConf_OrderedIndex_OrderedTaskMap orderedIndexTaskExpiryMap *TaskConf_OrderedIndex_TaskExpiryMap orderedIndexSortedTaskExpiryMap *TaskConf_OrderedIndex_SortedTaskExpiryMap + orderedIndexActivityExpiryMap *TaskConf_OrderedIndex_ActivityExpiryMap } // Name returns the TaskConf's message name. @@ -670,6 +686,7 @@ func (x *TaskConf) processAfterLoad() error { x.orderedIndexOrderedTaskMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexSortedTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() + x.orderedIndexActivityExpiryMap = treemap.New2[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task]() for _, item1 := range x.data.GetTaskMap() { { // OrderedIndex: Goal@OrderedTask @@ -689,6 +706,12 @@ func (x *TaskConf) processAfterLoad() error { value, _ := x.orderedIndexSortedTaskExpiryMap.Get(key) x.orderedIndexSortedTaskExpiryMap.Put(key, append(value, item1)) } + { + // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry + key := TaskConf_OrderedIndex_ActivityExpiryKey{item1.GetExpiry().GetSeconds(), item1.GetActivityId()} + value, _ := x.orderedIndexActivityExpiryMap.Get(key) + x.orderedIndexActivityExpiryMap.Put(key, append(value, item1)) + } } // OrderedIndex(sort): Goal@OrderedTask x.orderedIndexOrderedTaskMap.Range(func(key int64, item []*protoconf.TaskConf_Task) bool { @@ -816,6 +839,30 @@ func (x *TaskConf) FindFirstSortedTaskExpiry(expiry int64) *protoconf.TaskConf_T return nil } +// OrderedIndex: (Expiry,ActivityID)@ActivityExpiry + +// FindActivityExpiryMap finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (protoconf.TaskConf_Task) treemap. +// One key may correspond to multiple values, which are contained by a slice. +func (x *TaskConf) FindActivityExpiryMap() *TaskConf_OrderedIndex_ActivityExpiryMap { + return x.orderedIndexActivityExpiryMap +} + +// FindActivityExpiry finds a slice of all values of the given key. +func (x *TaskConf) FindActivityExpiry(expiry int64, activityId int64) []*protoconf.TaskConf_Task { + val, _ := x.orderedIndexActivityExpiryMap.Get(TaskConf_OrderedIndex_ActivityExpiryKey{expiry, activityId}) + return val +} + +// FindFirstActivityExpiry finds the first value of the given key, +// or nil if no value found. +func (x *TaskConf) FindFirstActivityExpiry(expiry int64, activityId int64) *protoconf.TaskConf_Task { + val := x.FindActivityExpiry(expiry, activityId) + if len(val) > 0 { + return val[0] + } + return nil +} + func init() { Register(func() Messager { return new(ActivityConf) diff --git a/test/proto/item_conf.proto b/test/proto/item_conf.proto index 218deb5f..7c143864 100644 --- a/test/proto/item_conf.proto +++ b/test/proto/item_conf.proto @@ -16,6 +16,8 @@ message ItemConf { option (tableau.worksheet) = { name: "ItemConf" ordered_map: true + ordered_index: "ExtType@ExtType" + ordered_index: "(Param,ExtType)@ParamExtType" index: "Type" index: "Param@ItemInfo" index: "Default@ItemDefaultInfo" // For testing programming language keyword conflicts @@ -53,7 +55,9 @@ message Path { } message UseEffect { - option (tableau.union) = {name: "UseEffect"}; + option (tableau.union) = { + name: "UseEffect" + }; Type type = 9999 [(tableau.field) = { name: "Type" }]; oneof value { diff --git a/test/proto/test_conf.proto b/test/proto/test_conf.proto index 2f86aa4c..977b639d 100644 --- a/test/proto/test_conf.proto +++ b/test/proto/test_conf.proto @@ -103,6 +103,7 @@ message TaskConf { ordered_index: "Goal@OrderedTask" ordered_index: "Expiry@TaskExpiry" ordered_index: "Expiry@SortedTaskExpiry" + ordered_index: "(Expiry,ActivityID)@ActivityExpiry" }; map task_map = 1 [(tableau.field) = { key: "ID" layout: LAYOUT_VERTICAL }]; From e1b507d0b415e0ca6f1891a0e3b6f43730dd49c0 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Tue, 11 Nov 2025 21:47:49 +0800 Subject: [PATCH 2/8] feat: test code --- .../helper/helper.go | 57 ++-- .../helper/imports.go | 16 + cmd/protoc-gen-go-tableau-loader/index.go | 231 ------------- .../index/index.go | 273 +++++++++++++++ cmd/protoc-gen-go-tableau-loader/messager.go | 116 ++----- .../ordered_index.go | 271 --------------- .../ordered_index/ordered_index.go | 310 ++++++++++++++++++ .../ordered_map.go | 202 ------------ .../ordered_map/ordered_map.go | 248 ++++++++++++++ 9 files changed, 916 insertions(+), 808 deletions(-) create mode 100644 cmd/protoc-gen-go-tableau-loader/helper/imports.go delete mode 100644 cmd/protoc-gen-go-tableau-loader/index.go create mode 100644 cmd/protoc-gen-go-tableau-loader/index/index.go delete mode 100644 cmd/protoc-gen-go-tableau-loader/ordered_index.go create mode 100644 cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go delete mode 100644 cmd/protoc-gen-go-tableau-loader/ordered_map.go create mode 100644 cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go diff --git a/cmd/protoc-gen-go-tableau-loader/helper/helper.go b/cmd/protoc-gen-go-tableau-loader/helper/helper.go index 361d7973..f874f5bf 100644 --- a/cmd/protoc-gen-go-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-go-tableau-loader/helper/helper.go @@ -130,6 +130,25 @@ func ParseOrderedMapKeyType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd } } +func ParseMapFieldName(fd protoreflect.FieldDescriptor) string { + opts := fd.Options().(*descriptorpb.FieldOptions) + fdOpts := proto.GetExtension(opts, tableaupb.E_Field).(*tableaupb.FieldOptions) + name := fdOpts.GetKey() + if fd.MapValue().Kind() == protoreflect.MessageKind { + valueFd := fd.MapValue().Message().Fields().Get(0) + name = string(valueFd.Name()) + } + return escapeIdentifier(name) +} + +func ParseMapValueType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd protoreflect.FieldDescriptor) string { + valueType := ParseGoType(gen, g, fd.MapValue()) + if fd.MapValue().Kind() == protoreflect.MessageKind { + return "*" + valueType + } + return valueType +} + func FindMessage(gen *protogen.Plugin, md protoreflect.MessageDescriptor) *protogen.Message { if file, ok := gen.FilesByPath[md.ParentFile().Path()]; ok { return FindMessageByDescriptor(file.Messages, md) @@ -224,36 +243,30 @@ func GetTypeEmptyValue(fd protoreflect.FieldDescriptor) string { } type MapKey struct { - Type string - Name string + Type string + Name string + FieldName string // multi-colunm index only } -func AddMapKey(gen *protogen.Plugin, fd protoreflect.FieldDescriptor, keys []MapKey) []MapKey { - opts := fd.Options().(*descriptorpb.FieldOptions) - fdOpts := proto.GetExtension(opts, tableaupb.E_Field).(*tableaupb.FieldOptions) - name := fdOpts.GetKey() - if fd.MapValue().Kind() == protoreflect.MessageKind { - valueFd := fd.MapValue().Message().Fields().Get(0) - name = string(valueFd.Name()) +type MapKeys []MapKey + +func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { + if newKey.Name == "" { + newKey.Name = fmt.Sprintf("key%d", len(keys)+1) } - name = escapeIdentifier(name) - if name == "" { - name = fmt.Sprintf("key%d", len(keys)+1) - } else { - for _, key := range keys { - if key.Name == name { - // rewrite to avoid name confict - name = fmt.Sprintf("%s%d", name, len(keys)+1) - break - } + for _, key := range keys { + if key.Name == newKey.Name { + // rewrite to avoid name confict + newKey.Name = fmt.Sprintf("%s%d", newKey.Name, len(keys)+1) + break } } - keys = append(keys, MapKey{ParseMapKeyType(fd.MapKey()), name}) + keys = append(keys, newKey) return keys } // GenGetParams generates function parameters, which are the names listed in the function's definition. -func GenGetParams(keys []MapKey) string { +func (keys MapKeys) GenGetParams() string { var params string for i, key := range keys { params += key.Name + " " + key.Type @@ -265,7 +278,7 @@ func GenGetParams(keys []MapKey) string { } // GenGetArguments generates function arguments, which are the real values passed to the function. -func GenGetArguments(keys []MapKey) string { +func (keys MapKeys) GenGetArguments() string { var params string for i, key := range keys { params += key.Name diff --git a/cmd/protoc-gen-go-tableau-loader/helper/imports.go b/cmd/protoc-gen-go-tableau-loader/helper/imports.go new file mode 100644 index 00000000..6b34cfde --- /dev/null +++ b/cmd/protoc-gen-go-tableau-loader/helper/imports.go @@ -0,0 +1,16 @@ +package helper + +import "google.golang.org/protobuf/compiler/protogen" + +const ( + FormatPackage = protogen.GoImportPath("github.com/tableauio/tableau/format") + LoadPackage = protogen.GoImportPath("github.com/tableauio/tableau/load") + StorePackage = protogen.GoImportPath("github.com/tableauio/tableau/store") + Errors = protogen.GoImportPath("github.com/pkg/errors") + TreeMapPackage = protogen.GoImportPath("github.com/tableauio/loader/pkg/treemap") + PairPackage = protogen.GoImportPath("github.com/tableauio/loader/pkg/pair") + TimePackage = protogen.GoImportPath("time") + SortPackage = protogen.GoImportPath("sort") + FmtPackage = protogen.GoImportPath("fmt") + ProtoPackage = protogen.GoImportPath("google.golang.org/protobuf/proto") +) diff --git a/cmd/protoc-gen-go-tableau-loader/index.go b/cmd/protoc-gen-go-tableau-loader/index.go deleted file mode 100644 index 52dbec45..00000000 --- a/cmd/protoc-gen-go-tableau-loader/index.go +++ /dev/null @@ -1,231 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/iancoleman/strcase" - "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" - "github.com/tableauio/loader/internal/index" - "google.golang.org/protobuf/compiler/protogen" -) - -func genIndexTypeDef(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - g.P("// Index types.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take first field - g.P("// Index: ", index.Index) - mapType := fmt.Sprintf("%s_Index_%sMap", messagerName, index.Name()) - keyType := helper.ParseGoType(gen, g, field.FD) - g.P("type ", mapType, " = map[", keyType, "][]*", helper.FindMessageGoIdent(gen, index.MD)) - } else { - // multi-column index - g.P("// Index: ", index.Index) - keyType := fmt.Sprintf("%s_Index_%sKey", messagerName, index.Name()) - mapType := fmt.Sprintf("%s_Index_%sMap", messagerName, index.Name()) - - // generate key struct - // KeyType must be comparable, refer https://go.dev/blog/maps - g.P("type ", keyType, " struct {") - for _, field := range index.ColFields { - g.P(helper.ParseIndexFieldNameAsKeyStructFieldName(gen, field.FD), " ", helper.ParseGoType(gen, g, field.FD)) - } - g.P("}") - g.P("type ", mapType, " = map[", keyType, "][]*", helper.FindMessageGoIdent(gen, index.MD)) - } - g.P() - } - } -} - -func genIndexField(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - mapType := fmt.Sprintf("%s_Index_%sMap", messagerName, index.Name()) - g.P(indexContainerName, " ", mapType) - } - } -} - -func genIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - g.P("// Index init.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - g.P("x.", indexContainerName, " = make(", fmt.Sprintf("%s_Index_%sMap", messagerName, index.Name()), ")") - } - } - parentDataName := "x.data" - depth := 1 - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - genOneIndexLoader(gen, g, depth, index, parentDataName, messagerName) - } - itemName := fmt.Sprintf("item%d", depth) - if levelMessage.FD == nil { - break - } - if !levelMessage.NextLevel.NeedGen() { - break - } - g.P("for _, ", itemName, " := range ", parentDataName, ".Get", helper.ParseIndexFieldName(gen, levelMessage.FD), "() {") - parentDataName = itemName - depth++ - } - for i := depth - 1; i > 0; i-- { - g.P("}") - } - genIndexSorter(gen, g, descriptor) -} - -func genOneIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, depth int, index *index.LevelIndex, - parentDataName string, messagerName string) { - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - g.P("{") - g.P("// Index: ", index.Index) - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take the first field - if field.FD.IsList() { - itemName := fmt.Sprintf("item%d", depth) - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - g.P("key := ", itemName) - g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") - g.P("}") - } else { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - g.P("key := ", parentDataName, fieldName) - g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") - } - } else { - // multi-column index - generateOneMulticolumnIndex(gen, g, depth, index, parentDataName, messagerName, nil) - } - g.P("}") -} - -func genIndexSorter(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - if len(index.SortedColFields) != 0 { - g.P("// Index(sort): ", index.Index) - g.P("for _, item := range x.", indexContainerName, " {") - g.P(sortPackage.Ident("Slice"), "(item, func(i, j int) bool {") - for i, field := range index.SortedColFields { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - if i == len(index.SortedColFields)-1 { - g.P("return item[i]", fieldName, " < item[j]", fieldName) - } else { - g.P("if item[i]", fieldName, " != item[j]", fieldName, " {") - g.P("return item[i]", fieldName, " < item[j]", fieldName) - g.P("}") - } - } - g.P("})") - g.P("}") - } - } - } -} - -func generateOneMulticolumnIndex(gen *protogen.Plugin, g *protogen.GeneratedFile, - depth int, index *index.LevelIndex, parentDataName string, messagerName string, keys []string) []string { - cursor := len(keys) - if cursor >= len(index.ColFields) { - var keyParams string - for i, key := range keys { - keyParams += key - if i != len(keys)-1 { - keyParams += ", " - } - } - keyType := fmt.Sprintf("%s_Index_%sKey", messagerName, index.Name()) - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - g.P("key := ", keyType, " {", keyParams, "}") - g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") - return keys - } - field := index.ColFields[cursor] - if field.FD.IsList() { - itemName := fmt.Sprintf("indexItem%d", cursor) - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - keys = append(keys, itemName) - keys = generateOneMulticolumnIndex(gen, g, depth+1, index, parentDataName, messagerName, keys) - g.P("}") - } else { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - key := parentDataName + fieldName - keys = append(keys, key) - keys = generateOneMulticolumnIndex(gen, g, depth, index, parentDataName, messagerName, keys) - } - return keys -} - -func genIndexFinders(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - mapType := fmt.Sprintf("%s_Index_%sMap", messagerName, index.Name()) - indexContainerName := "index" + strcase.ToCamel(index.Name()) + "Map" - - g.P("// Index: ", index.Index) - g.P() - - g.P("// Find", index.Name(), "Map finds the index (", index.Index, ") to value (", helper.FindMessageGoIdent(gen, index.MD), ") map.") - g.P("// One key may correspond to multiple values, which are contained by a slice.") - g.P("func (x *", messagerName, ") Find", index.Name(), "Map() ", mapType, " {") - g.P("return x.", indexContainerName) - g.P("}") - g.P() - - var keys []helper.MapKey - for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ - Type: helper.ParseGoType(gen, g, field.FD), - Name: helper.ParseIndexFieldNameAsFuncParam(gen, field.FD), - }) - } - - g.P("// Find", index.Name(), " finds a slice of all values of the given key.") - g.P("func (x *", messagerName, ") Find", index.Name(), "(", helper.GenGetParams(keys), ") []*", helper.FindMessageGoIdent(gen, index.MD), " {") - if len(index.ColFields) == 1 { - g.P("return x.", indexContainerName, "[", helper.GenGetArguments(keys), "]") - } else { - g.P("return x.", indexContainerName, "[", fmt.Sprintf("%s_Index_%sKey", messagerName, index.Name()), "{", helper.GenGetArguments(keys), "}]") - } - g.P("}") - g.P() - - g.P("// FindFirst", index.Name(), " finds the first value of the given key,") - g.P("// or nil if no value found.") - g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", helper.GenGetParams(keys), ") *", helper.FindMessageGoIdent(gen, index.MD), " {") - g.P("val := x.Find", index.Name(), "(", helper.GenGetArguments(keys), ")") - g.P("if len(val) > 0 {") - g.P("return val[0]") - g.P("}") - g.P("return nil") - g.P("}") - g.P() - } - } -} diff --git a/cmd/protoc-gen-go-tableau-loader/index/index.go b/cmd/protoc-gen-go-tableau-loader/index/index.go new file mode 100644 index 00000000..83cdd69d --- /dev/null +++ b/cmd/protoc-gen-go-tableau-loader/index/index.go @@ -0,0 +1,273 @@ +package index + +import ( + "fmt" + + "github.com/iancoleman/strcase" + "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" + "github.com/tableauio/loader/internal/index" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +type Generator struct { + gen *protogen.Plugin + g *protogen.GeneratedFile + descriptor *index.IndexDescriptor + message *protogen.Message +} + +func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, message *protogen.Message) *Generator { + return &Generator{ + gen: gen, + g: g, + descriptor: descriptor, + message: message, + } +} + +func (x *Generator) generate() bool { + return options.NeedGenIndex(x.message.Desc, options.LangGO) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) mapType(index *index.LevelIndex) string { + return fmt.Sprintf("%s_Index_%sMap", x.messagerName(), index.Name()) +} + +func (x *Generator) mapKeyType(index *index.LevelIndex) string { + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + return helper.ParseGoType(x.gen, x.g, field.FD) + } else { + // multi-column index + return fmt.Sprintf("%s_Index_%sKey", x.messagerName(), index.Name()) + } +} + +func (x *Generator) mapValueType(index *index.LevelIndex) protogen.GoIdent { + return helper.FindMessageGoIdent(x.gen, index.MD) +} + +func (x *Generator) indexContainerName(index *index.LevelIndex) string { + return fmt.Sprintf("index%sMap", strcase.ToCamel(index.Name())) +} + +func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { + var keys []helper.MapKey + for _, field := range index.ColFields { + keys = append(keys, helper.MapKey{ + Type: helper.ParseGoType(x.gen, x.g, field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(x.gen, field.FD), + FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(x.gen, field.FD), + }) + } + return keys +} + +func (x *Generator) fieldGetter(fd protoreflect.FieldDescriptor) string { + return fmt.Sprintf(".Get%s()", helper.ParseIndexFieldName(x.gen, fd)) +} + +func (x *Generator) parseKeyFieldName(field *index.LevelField) string { + var fieldName string + for _, leveledFd := range field.LeveledFDList { + fieldName += x.fieldGetter(leveledFd) + } + return fieldName +} + +func (x *Generator) GenIndexTypeDef() { + if !x.generate() { + return + } + x.g.P("// Index types.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.g.P("// Index: ", index.Index) + if len(index.ColFields) != 1 { + // multi-column index + keyType := x.mapKeyType(index) + keys := x.indexKeys(index) + + // generate key struct + // KeyType must be comparable, refer https://go.dev/blog/maps + x.g.P("type ", keyType, " struct {") + for _, key := range keys { + x.g.P(key.FieldName, " ", key.Type) + } + x.g.P("}") + } + x.g.P("type ", x.mapType(index), " = map[", x.mapKeyType(index), "][]*", x.mapValueType(index)) + x.g.P() + } + } +} + +func (x *Generator) GenIndexField() { + if !x.generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.g.P(x.indexContainerName(index), " ", x.mapType(index)) + } + } +} + +func (x *Generator) GenIndexLoader() { + if !x.generate() { + return + } + x.g.P("// Index init.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.g.P("x.", x.indexContainerName(index), " = make(", x.mapType(index), ")") + } + } + parentDataName := "x.data" + depth := 1 + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.genOneIndexLoader(index, depth, parentDataName) + } + itemName := fmt.Sprintf("item%d", depth) + if levelMessage.FD == nil { + break + } + if !levelMessage.NextLevel.NeedGen() { + break + } + x.g.P("for _, ", itemName, " := range ", parentDataName, x.fieldGetter(levelMessage.FD), " {") + parentDataName = itemName + depth++ + } + for i := depth - 1; i > 0; i-- { + x.g.P("}") + } + x.genIndexSorter() +} + +func (x *Generator) genOneIndexLoader(index *index.LevelIndex, depth int, parentDataName string) { + x.g.P("{") + x.g.P("// Index: ", index.Index) + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take the first field + fieldName := x.parseKeyFieldName(field) + indexContainerName := x.indexContainerName(index) + if field.FD.IsList() { + itemName := fmt.Sprintf("item%d", depth) + x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + x.g.P("key := ", itemName) + x.g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") + x.g.P("}") + } else { + x.g.P("key := ", parentDataName, fieldName) + x.g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") + } + } else { + // multi-column index + x.generateOneMulticolumnIndex(depth, index, parentDataName, nil) + } + x.g.P("}") +} + +func (x *Generator) generateOneMulticolumnIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) helper.MapKeys { + cursor := len(keys) + if cursor >= len(index.ColFields) { + keyType := x.mapKeyType(index) + indexContainerName := x.indexContainerName(index) + x.g.P("key := ", keyType, " {", keys.GenGetArguments(), "}") + x.g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") + return keys + } + field := index.ColFields[cursor] + fieldName := x.parseKeyFieldName(field) + if field.FD.IsList() { + itemName := fmt.Sprintf("indexItem%d", cursor) + x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + keys = append(keys, helper.MapKey{Name: itemName}) + keys = x.generateOneMulticolumnIndex(depth+1, index, parentDataName, keys) + x.g.P("}") + } else { + key := parentDataName + fieldName + keys = append(keys, helper.MapKey{Name: key}) + keys = x.generateOneMulticolumnIndex(depth, index, parentDataName, keys) + } + return keys +} + +func (x *Generator) genIndexSorter() { + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + if len(index.SortedColFields) != 0 { + x.g.P("// Index(sort): ", index.Index) + x.g.P("for _, item := range x.", x.indexContainerName(index), " {") + x.g.P(helper.SortPackage.Ident("Slice"), "(item, func(i, j int) bool {") + for i, field := range index.SortedColFields { + fieldName := x.parseKeyFieldName(field) + if i == len(index.SortedColFields)-1 { + x.g.P("return item[i]", fieldName, " < item[j]", fieldName) + } else { + x.g.P("if item[i]", fieldName, " != item[j]", fieldName, " {") + x.g.P("return item[i]", fieldName, " < item[j]", fieldName) + x.g.P("}") + } + } + x.g.P("})") + x.g.P("}") + } + } + } +} + +func (x *Generator) GenIndexFinders() { + if !x.generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + indexContainerName := x.indexContainerName(index) + messagerName := x.messagerName() + x.g.P("// Index: ", index.Index) + x.g.P() + + x.g.P("// Find", index.Name(), "Map finds the index (", index.Index, ") to value (", x.mapValueType(index), ") map.") + x.g.P("// One key may correspond to multiple values, which are contained by a slice.") + x.g.P("func (x *", messagerName, ") Find", index.Name(), "Map() ", x.mapType(index), " {") + x.g.P("return x.", indexContainerName) + x.g.P("}") + x.g.P() + + keys := x.indexKeys(index) + params := keys.GenGetParams() + args := keys.GenGetArguments() + x.g.P("// Find", index.Name(), " finds a slice of all values of the given key.") + x.g.P("func (x *", messagerName, ") Find", index.Name(), "(", params, ") []*", x.mapValueType(index), " {") + if len(index.ColFields) == 1 { + x.g.P("return x.", indexContainerName, "[", args, "]") + } else { + x.g.P("return x.", indexContainerName, "[", x.mapKeyType(index), "{", args, "}]") + } + x.g.P("}") + x.g.P() + + x.g.P("// FindFirst", index.Name(), " finds the first value of the given key,") + x.g.P("// or nil if no value found.") + x.g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", params, ") *", x.mapValueType(index), " {") + x.g.P("val := x.Find", index.Name(), "(", args, ")") + x.g.P("if len(val) > 0 {") + x.g.P("return val[0]") + x.g.P("}") + x.g.P("return nil") + x.g.P("}") + x.g.P() + } + } +} diff --git a/cmd/protoc-gen-go-tableau-loader/messager.go b/cmd/protoc-gen-go-tableau-loader/messager.go index ec0df01a..e74acdb8 100644 --- a/cmd/protoc-gen-go-tableau-loader/messager.go +++ b/cmd/protoc-gen-go-tableau-loader/messager.go @@ -4,6 +4,9 @@ import ( "fmt" "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" + idx "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/index" + orderedindex "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/ordered_index" + orderedmap "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/ordered_map" "github.com/tableauio/loader/internal/extensions" "github.com/tableauio/loader/internal/index" "github.com/tableauio/loader/internal/options" @@ -14,19 +17,6 @@ import ( "google.golang.org/protobuf/types/descriptorpb" ) -const ( - formatPackage = protogen.GoImportPath("github.com/tableauio/tableau/format") - loadPackage = protogen.GoImportPath("github.com/tableauio/tableau/load") - storePackage = protogen.GoImportPath("github.com/tableauio/tableau/store") - errors = protogen.GoImportPath("github.com/pkg/errors") - treeMapPackage = protogen.GoImportPath("github.com/tableauio/loader/pkg/treemap") - pairPackage = protogen.GoImportPath("github.com/tableauio/loader/pkg/pair") - timePackage = protogen.GoImportPath("time") - sortPackage = protogen.GoImportPath("sort") - fmtPackage = protogen.GoImportPath("fmt") - protoPackage = protogen.GoImportPath("google.golang.org/protobuf/proto") -) - // golbal container for record all proto filenames and messager names var messagers []string @@ -75,16 +65,14 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog messagerName := string(message.Desc.Name()) indexDescriptor := index.ParseIndexDescriptor(message.Desc) + orderedMapGenerator := orderedmap.NewGenerator(gen, g, message) + indexGenerator := idx.NewGenerator(gen, g, indexDescriptor, message) + orderedIndexGenerator := orderedindex.NewGenerator(gen, g, indexDescriptor, message) + // type definitions - if options.NeedGenOrderedMap(message.Desc, options.LangGO) { - genOrderedMapTypeDef(gen, g, message.Desc, 1, nil, messagerName) - } - if options.NeedGenIndex(message.Desc, options.LangGO) { - genIndexTypeDef(gen, g, indexDescriptor, messagerName) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangGO) { - genOrderedIndexTypeDef(gen, g, indexDescriptor, messagerName) - } + orderedMapGenerator.GenOrderedMapTypeDef() + indexGenerator.GenIndexTypeDef() + orderedIndexGenerator.GenOrderedIndexTypeDef() g.P("// ", messagerName, " is a wrapper around protobuf message: ", message.GoIdent, ".") g.P("//") @@ -97,15 +85,9 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog g.P("type ", messagerName, " struct {") g.P("UnimplementedMessager") g.P("data, originalData *", message.GoIdent) - if options.NeedGenOrderedMap(message.Desc, options.LangGO) { - genOrderedMapField(g, message.Desc) - } - if options.NeedGenIndex(message.Desc, options.LangGO) { - genIndexField(g, indexDescriptor, messagerName) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangGO) { - genOrderedIndexField(g, indexDescriptor, messagerName) - } + orderedMapGenerator.GenOrderedMapField() + indexGenerator.GenIndexField() + orderedIndexGenerator.GenOrderedIndexField() g.P("}") g.P() @@ -129,13 +111,13 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog g.P() g.P("// Load fills ", messagerName, "'s inner message from file in the specified directory and format.") - g.P("func (x *", messagerName, ") Load(dir string, format ", formatPackage.Ident("Format"), " , opts *", loadPackage.Ident("MessagerOptions"), ") error {") - g.P("start := ", timePackage.Ident("Now"), "()") + g.P("func (x *", messagerName, ") Load(dir string, format ", helper.FormatPackage.Ident("Format"), " , opts *", helper.LoadPackage.Ident("MessagerOptions"), ") error {") + g.P("start := ", helper.TimePackage.Ident("Now"), "()") g.P("defer func () {") - g.P("x.Stats.Duration = ", timePackage.Ident("Since"), "(start)") + g.P("x.Stats.Duration = ", helper.TimePackage.Ident("Since"), "(start)") g.P("}()") g.P("x.data = &", message.GoIdent, "{}") - g.P("err := ", loadPackage.Ident("LoadMessagerInDir"), "(x.data, dir, format, opts)") + g.P("err := ", helper.LoadPackage.Ident("LoadMessagerInDir"), "(x.data, dir, format, opts)") g.P("if err != nil {") g.P("return err") g.P("}") @@ -148,13 +130,13 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog g.P("// Store writes ", messagerName, "'s inner message to file in the specified directory and format.") g.P("// Available formats: JSON, Bin, and Text.") - g.P("func (x *", messagerName, ") Store(dir string, format ", formatPackage.Ident("Format"), " , options ...", storePackage.Ident("Option"), ") error {") - g.P("return ", storePackage.Ident("Store"), "(x.Data(), dir, format, options...)") + g.P("func (x *", messagerName, ") Store(dir string, format ", helper.FormatPackage.Ident("Format"), " , options ...", helper.StorePackage.Ident("Option"), ") error {") + g.P("return ", helper.StorePackage.Ident("Store"), "(x.Data(), dir, format, options...)") g.P("}") g.P() g.P("// Message returns the ", messagerName, "'s inner message data.") - g.P("func (x *", messagerName, ") Message() ", protoPackage.Ident("Message"), " {") + g.P("func (x *", messagerName, ") Message() ", helper.ProtoPackage.Ident("Message"), " {") g.P(`return x.Data()`) g.P("}") g.P() @@ -177,15 +159,9 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog if options.NeedGenOrderedMap(message.Desc, options.LangGO) || options.NeedGenIndex(message.Desc, options.LangGO) || options.NeedGenOrderedIndex(message.Desc, options.LangGO) { g.P("// processAfterLoad runs after this messager is loaded.") g.P("func (x *", messagerName, ") processAfterLoad() error {") - if options.NeedGenOrderedMap(message.Desc, options.LangGO) { - genOrderedMapLoader(gen, g, message.Desc, 1, nil, messagerName, "") - } - if options.NeedGenIndex(message.Desc, options.LangGO) { - genIndexLoader(gen, g, indexDescriptor, messagerName) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangGO) { - genOrderedIndexLoader(gen, g, indexDescriptor, messagerName) - } + orderedMapGenerator.GenOrderedMapLoader() + indexGenerator.GenIndexLoader() + orderedIndexGenerator.GenOrderedIndexLoader() g.P("return nil") g.P("}") g.P() @@ -193,26 +169,23 @@ func genMessage(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protog // syntactic sugar for accessing map items genMapGetters(gen, g, message, 1, nil, messagerName) - if options.NeedGenOrderedMap(message.Desc, options.LangGO) { - genOrderedMapGetters(gen, g, message.Desc, 1, nil, messagerName) - } - if options.NeedGenIndex(message.Desc, options.LangGO) { - genIndexFinders(gen, g, indexDescriptor, messagerName) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangGO) { - genOrderedIndexFinders(gen, g, indexDescriptor, messagerName) - } + orderedMapGenerator.GenOrderedMapGetters() + indexGenerator.GenIndexFinders() + orderedIndexGenerator.GenOrderedIndexFinders() } -func genMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protogen.Message, depth int, keys []helper.MapKey, messagerName string) { +func genMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protogen.Message, depth int, keys helper.MapKeys, messagerName string) { for _, field := range message.Fields { fd := field.Desc if fd.IsMap() { - keys = helper.AddMapKey(gen, fd, keys) + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) getter := fmt.Sprintf("Get%v", depth) g.P("// ", getter, " finds value in the ", depth, "-level map. It will return") g.P("// NotFound error if the key is not found.") - g.P("func (x *", messagerName, ") ", getter, "(", helper.GenGetParams(keys), ") (", parseMapValueType(gen, g, fd), ", error) {") + g.P("func (x *", messagerName, ") ", getter, "(", keys.GenGetParams(), ") (", helper.ParseMapValueType(gen, g, fd), ", error) {") returnEmptyValue := helper.GetTypeEmptyValue(fd.MapValue()) @@ -223,7 +196,7 @@ func genMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, message *pro container = "conf" prevKeys := keys[:len(keys)-1] prevGetter := fmt.Sprintf("Get%v", depth-1) - g.P("conf, err := x.", prevGetter, "(", helper.GenGetArguments(prevKeys), ")") + g.P("conf, err := x.", prevGetter, "(", prevKeys.GenGetArguments(), ")") g.P("if err != nil {") g.P(`return `, returnEmptyValue, `, err`) g.P("}") @@ -232,7 +205,7 @@ func genMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, message *pro g.P("d := ", container, ".Get", field.GoName, "()") lastKeyName := keys[len(keys)-1].Name g.P("if val, ok := d[", lastKeyName, "]; !ok {") - g.P(`return `, returnEmptyValue, `, `, fmtPackage.Ident("Errorf"), `("`, lastKeyName, `(%v) %w", `, lastKeyName, `, ErrNotFound)`) + g.P(`return `, returnEmptyValue, `, `, helper.FmtPackage.Ident("Errorf"), `("`, lastKeyName, `(%v) %w", `, lastKeyName, `, ErrNotFound)`) g.P("} else {") g.P(`return val, nil`) g.P("}") @@ -249,24 +222,3 @@ func genMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, message *pro } } } - -func getNextLevelMapFD(fd protoreflect.FieldDescriptor) protoreflect.FieldDescriptor { - if fd.Kind() == protoreflect.MessageKind { - md := fd.Message() - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - return fd - } - } - } - return nil -} - -func parseMapValueType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd protoreflect.FieldDescriptor) string { - valueType := helper.ParseGoType(gen, g, fd.MapValue()) - if fd.MapValue().Kind() == protoreflect.MessageKind { - return "*" + valueType - } - return valueType -} diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index.go deleted file mode 100644 index b185a9e2..00000000 --- a/cmd/protoc-gen-go-tableau-loader/ordered_index.go +++ /dev/null @@ -1,271 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/iancoleman/strcase" - "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" - "github.com/tableauio/loader/internal/index" - "google.golang.org/protobuf/compiler/protogen" -) - -func genOrderedIndexTypeDef(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - g.P("// OrderedIndex types.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take first field - g.P("// OrderedIndex: ", index.Index) - mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) - keyType := helper.ParseOrderedMapKeyType(gen, g, field.FD) - g.P("type ", mapType, " = ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]") - } else { - // multi-column index - g.P("// OrderedIndex: ", index.Index) - keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) - mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) - - // generate key struct - // KeyType must be comparable, refer https://go.dev/blog/maps - g.P("type ", keyType, " struct {") - for _, field := range index.ColFields { - g.P(helper.ParseIndexFieldNameAsKeyStructFieldName(gen, field.FD), " ", helper.ParseOrderedMapKeyType(gen, g, field.FD)) - } - g.P("}") - g.P() - g.P("func (x ", keyType, ") Less(other ", keyType, ") bool {") - for i, field := range index.ColFields { - fieldName := helper.ParseIndexFieldNameAsKeyStructFieldName(gen, field.FD) - if i == len(index.ColFields)-1 { - g.P("return x.", fieldName, " < other.", fieldName) - } else { - g.P("if x.", fieldName, " != other.", fieldName, " {") - g.P("return x.", fieldName, " < other.", fieldName) - g.P("}") - } - } - g.P("}") - g.P() - g.P("type ", mapType, " = ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]") - } - g.P() - } - } -} - -func genOrderedIndexField(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) - g.P(indexContainerName, " *", mapType) - } - } -} - -func genOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - g.P("// OrderedIndex init.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - field := index.ColFields[0] // just take first field - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - if len(index.ColFields) == 1 { - keyType := helper.ParseOrderedMapKeyType(gen, g, field.FD) - g.P("x.", indexContainerName, " = ", treeMapPackage.Ident("New"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]()") - } else { - keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) - g.P("x.", indexContainerName, " = ", treeMapPackage.Ident("New2"), "[", keyType, ", []*", helper.FindMessageGoIdent(gen, index.MD), "]()") - } - } - } - parentDataName := "x.data" - depth := 1 - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - genOneOrderedIndexLoader(gen, g, depth, index, parentDataName, messagerName) - } - itemName := fmt.Sprintf("item%d", depth) - if levelMessage.FD == nil { - break - } - if !levelMessage.NextLevel.NeedGen() { - break - } - g.P("for _, ", itemName, " := range ", parentDataName, ".Get", helper.ParseIndexFieldName(gen, levelMessage.FD), "() {") - parentDataName = itemName - depth++ - } - for i := depth - 1; i > 0; i-- { - g.P("}") - } - genOrderedIndexSorter(gen, g, descriptor, messagerName) -} - -func genOneOrderedIndexLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, depth int, index *index.LevelIndex, - parentDataName string, messagerName string) { - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - g.P("{") - g.P("// OrderedIndex: ", index.Index) - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take the first field - if field.FD.IsList() { - itemName := fmt.Sprintf("item%d", depth) - fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) - g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - g.P("key := ", itemName, suffix) - g.P("value, _ := x.", indexContainerName, ".Get(key)") - g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") - g.P("}") - } else { - fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) - g.P("key := ", parentDataName, fieldName, suffix) - g.P("value, _ := x.", indexContainerName, ".Get(key)") - g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") - } - } else { - // multi-column index - generateOneMulticolumnOrderedIndex(gen, g, depth, index, parentDataName, messagerName, nil) - } - g.P("}") -} - -func parseOrderedIndexKeyFieldNameAndSuffix(gen *protogen.Plugin, field *index.LevelField) (string, string) { - var fieldName, suffix string - for i, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { - switch leveledFd.Message().FullName() { - case "google.protobuf.Timestamp", "google.protobuf.Duration": - suffix = ".GetSeconds()" - default: - } - } - } - return fieldName, suffix -} - -func generateOneMulticolumnOrderedIndex(gen *protogen.Plugin, g *protogen.GeneratedFile, - depth int, index *index.LevelIndex, parentDataName string, messagerName string, keys []string) []string { - cursor := len(keys) - if cursor >= len(index.ColFields) { - var keyParams string - for i, key := range keys { - keyParams += key - if i != len(keys)-1 { - keyParams += ", " - } - } - keyType := fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - g.P("key := ", keyType, " {", keyParams, "}") - g.P("value, _ := x.", indexContainerName, ".Get(key)") - g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") - return keys - } - field := index.ColFields[cursor] - if field.FD.IsList() { - itemName := fmt.Sprintf("indexItem%d", cursor) - fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) - g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - key := itemName + suffix - keys = append(keys, key) // fixme:keys - keys = generateOneMulticolumnOrderedIndex(gen, g, depth+1, index, parentDataName, messagerName, keys) - g.P("}") - } else { - fieldName, suffix := parseOrderedIndexKeyFieldNameAndSuffix(gen, field) - key := parentDataName + fieldName + suffix - keys = append(keys, key) - keys = generateOneMulticolumnOrderedIndex(gen, g, depth, index, parentDataName, messagerName, keys) - } - return keys -} - -func genOrderedIndexSorter(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - if len(index.SortedColFields) != 0 { - g.P("// OrderedIndex(sort): ", index.Index) - var keyType string - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take first field - keyType = helper.ParseOrderedMapKeyType(gen, g, field.FD) - } else { - // multi-column index - keyType = fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()) - } - g.P("x.", indexContainerName, ".Range(func(key ", keyType, ", item []*", helper.FindMessageGoIdent(gen, index.MD), ") bool {") - g.P(sortPackage.Ident("Slice"), "(item, func(i, j int) bool {") - for i, field := range index.SortedColFields { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += ".Get" + helper.ParseIndexFieldName(gen, leveledFd) + "()" - } - if i == len(index.SortedColFields)-1 { - g.P("return item[i]", fieldName, " < item[j]", fieldName) - } else { - g.P("if item[i]", fieldName, " != item[j]", fieldName, " {") - g.P("return item[i]", fieldName, " < item[j]", fieldName) - g.P("}") - } - } - g.P("})") - g.P("return true") - g.P("})") - } - } - } -} - -func genOrderedIndexFinders(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - mapType := fmt.Sprintf("%s_OrderedIndex_%sMap", messagerName, index.Name()) - indexContainerName := "orderedIndex" + strcase.ToCamel(index.Name()) + "Map" - - g.P("// OrderedIndex: ", index.Index) - g.P() - - g.P("// Find", index.Name(), "Map finds the ordered index (", index.Index, ") to value (", helper.FindMessageGoIdent(gen, index.MD), ") treemap.") - g.P("// One key may correspond to multiple values, which are contained by a slice.") - g.P("func (x *", messagerName, ") Find", index.Name(), "Map() *", mapType, " {") - g.P("return x.", indexContainerName) - g.P("}") - g.P() - - var keys []helper.MapKey - for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ - Type: helper.ParseOrderedMapKeyType(gen, g, field.FD), - Name: helper.ParseIndexFieldNameAsFuncParam(gen, field.FD), - }) - } - - g.P("// Find", index.Name(), " finds a slice of all values of the given key.") - g.P("func (x *", messagerName, ") Find", index.Name(), "(", helper.GenGetParams(keys), ") []*", helper.FindMessageGoIdent(gen, index.MD), " {") - if len(index.ColFields) == 1 { - g.P("val, _ := x.", indexContainerName, ".Get(", helper.GenGetArguments(keys), ")") - g.P("return val") - } else { - g.P("val, _ := x.", indexContainerName, ".Get(", fmt.Sprintf("%s_OrderedIndex_%sKey", messagerName, index.Name()), "{", helper.GenGetArguments(keys), "})") - g.P("return val") - } - g.P("}") - g.P() - - g.P("// FindFirst", index.Name(), " finds the first value of the given key,") - g.P("// or nil if no value found.") - g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", helper.GenGetParams(keys), ") *", helper.FindMessageGoIdent(gen, index.MD), " {") - g.P("val := x.Find", index.Name(), "(", helper.GenGetArguments(keys), ")") - g.P("if len(val) > 0 {") - g.P("return val[0]") - g.P("}") - g.P("return nil") - g.P("}") - g.P() - } - } -} diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go new file mode 100644 index 00000000..131abc3b --- /dev/null +++ b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go @@ -0,0 +1,310 @@ +package orderedindex + +import ( + "fmt" + + "github.com/iancoleman/strcase" + "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" + "github.com/tableauio/loader/internal/index" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +type Generator struct { + gen *protogen.Plugin + g *protogen.GeneratedFile + descriptor *index.IndexDescriptor + message *protogen.Message +} + +func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, message *protogen.Message) *Generator { + return &Generator{ + gen: gen, + g: g, + descriptor: descriptor, + message: message, + } +} + +func (x *Generator) generate() bool { + return options.NeedGenOrderedIndex(x.message.Desc, options.LangGO) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) mapType(index *index.LevelIndex) string { + return fmt.Sprintf("%s_OrderedIndex_%sMap", x.messagerName(), index.Name()) +} + +func (x *Generator) mapKeyType(index *index.LevelIndex) string { + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + return helper.ParseOrderedMapKeyType(x.gen, x.g, field.FD) + } else { + // multi-column index + return fmt.Sprintf("%s_OrderedIndex_%sKey", x.messagerName(), index.Name()) + } +} + +func (x *Generator) mapValueType(index *index.LevelIndex) protogen.GoIdent { + return helper.FindMessageGoIdent(x.gen, index.MD) +} + +func (x *Generator) indexContainerName(index *index.LevelIndex) string { + return fmt.Sprintf("orderedIndex%sMap", strcase.ToCamel(index.Name())) +} + +func (x *Generator) mapCtor(index *index.LevelIndex) string { + if len(index.ColFields) == 1 { + // single-column index + return "New" + } else { + // multi-column index + return "New2" + } +} + +func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { + var keys []helper.MapKey + for _, field := range index.ColFields { + keys = append(keys, helper.MapKey{ + Type: helper.ParseOrderedMapKeyType(x.gen, x.g, field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(x.gen, field.FD), + FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(x.gen, field.FD), + }) + } + return keys +} + +func (x *Generator) fieldGetter(fd protoreflect.FieldDescriptor) string { + return fmt.Sprintf(".Get%s()", helper.ParseIndexFieldName(x.gen, fd)) +} + +func (x *Generator) parseKeyFieldNameAndSuffix(field *index.LevelField) (string, string) { + var fieldName, suffix string + for i, leveledFd := range field.LeveledFDList { + fieldName += x.fieldGetter(leveledFd) + if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { + switch leveledFd.Message().FullName() { + case "google.protobuf.Timestamp", "google.protobuf.Duration": + suffix = ".GetSeconds()" + default: + } + } + } + return fieldName, suffix +} + +func (x *Generator) GenOrderedIndexTypeDef() { + if !x.generate() { + return + } + x.g.P("// OrderedIndex types.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.g.P("// OrderedIndex: ", index.Index) + if len(index.ColFields) != 1 { + // multi-column index + keyType := x.mapKeyType(index) + keys := x.indexKeys(index) + + // generate key struct + x.g.P("type ", keyType, " struct {") + for _, key := range keys { + x.g.P(key.FieldName, " ", key.Type) + } + x.g.P("}") + x.g.P() + + // generate Less func to implement cmp.Ordered interface + x.g.P("func (x ", keyType, ") Less(other ", keyType, ") bool {") + for i, key := range keys { + if i == len(keys)-1 { + x.g.P("return x.", key.FieldName, " < other.", key.FieldName) + } else { + x.g.P("if x.", key.FieldName, " != other.", key.FieldName, " {") + x.g.P("return x.", key.FieldName, " < other.", key.FieldName) + x.g.P("}") + } + } + x.g.P("}") + x.g.P() + } + x.g.P("type ", x.mapType(index), " = ", helper.TreeMapPackage.Ident("TreeMap"), "[", x.mapKeyType(index), ", []*", x.mapValueType(index), "]") + x.g.P() + } + } +} + +func (x *Generator) GenOrderedIndexField() { + if !x.generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.g.P(x.indexContainerName(index), " *", x.mapType(index)) + } + } +} + +func (x *Generator) GenOrderedIndexLoader() { + if !x.generate() { + return + } + x.g.P("// OrderedIndex init.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.g.P("x.", x.indexContainerName(index), " = ", helper.TreeMapPackage.Ident(x.mapCtor(index)), "[", x.mapKeyType(index), ", []*", x.mapValueType(index), "]()") + } + } + parentDataName := "x.data" + depth := 1 + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.genOneOrderedIndexLoader(index, depth, parentDataName) + } + itemName := fmt.Sprintf("item%d", depth) + if levelMessage.FD == nil { + break + } + if !levelMessage.NextLevel.NeedGen() { + break + } + x.g.P("for _, ", itemName, " := range ", parentDataName, x.fieldGetter(levelMessage.FD), " {") + parentDataName = itemName + depth++ + } + for i := depth - 1; i > 0; i-- { + x.g.P("}") + } + x.genOrderedIndexSorter() +} + +func (x *Generator) genOneOrderedIndexLoader(index *index.LevelIndex, depth int, parentDataName string) { + x.g.P("{") + x.g.P("// OrderedIndex: ", index.Index) + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take the first field + fieldName, suffix := x.parseKeyFieldNameAndSuffix(field) + indexContainerName := x.indexContainerName(index) + if field.FD.IsList() { + itemName := fmt.Sprintf("item%d", depth) + x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + x.g.P("key := ", itemName, suffix) + x.g.P("value, _ := x.", indexContainerName, ".Get(key)") + x.g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") + x.g.P("}") + } else { + x.g.P("key := ", parentDataName, fieldName, suffix) + x.g.P("value, _ := x.", indexContainerName, ".Get(key)") + x.g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") + } + } else { + // multi-column index + x.generateOneMulticolumnOrderedIndex(depth, index, parentDataName, nil) + } + x.g.P("}") +} + +func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) helper.MapKeys { + cursor := len(keys) + if cursor >= len(index.ColFields) { + keyType := x.mapKeyType(index) + indexContainerName := x.indexContainerName(index) + x.g.P("key := ", keyType, " {", keys.GenGetArguments(), "}") + x.g.P("value, _ := x.", indexContainerName, ".Get(key)") + x.g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") + return keys + } + field := index.ColFields[cursor] + fieldName, suffix := x.parseKeyFieldNameAndSuffix(field) + if field.FD.IsList() { + itemName := fmt.Sprintf("indexItem%d", cursor) + x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") + key := itemName + suffix + keys = append(keys, helper.MapKey{Name: key}) + keys = x.generateOneMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) + x.g.P("}") + } else { + key := parentDataName + fieldName + suffix + keys = append(keys, helper.MapKey{Name: key}) + keys = x.generateOneMulticolumnOrderedIndex(depth, index, parentDataName, keys) + } + return keys +} + +func (x *Generator) genOrderedIndexSorter() { + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + if len(index.SortedColFields) != 0 { + x.g.P("// OrderedIndex(sort): ", index.Index) + x.g.P("x.", x.indexContainerName(index), ".Range(func(key ", x.mapKeyType(index), ", item []*", x.mapValueType(index), ") bool {") + x.g.P(helper.SortPackage.Ident("Slice"), "(item, func(i, j int) bool {") + for i, field := range index.SortedColFields { + fieldName, _ := x.parseKeyFieldNameAndSuffix(field) + if i == len(index.SortedColFields)-1 { + x.g.P("return item[i]", fieldName, " < item[j]", fieldName) + } else { + x.g.P("if item[i]", fieldName, " != item[j]", fieldName, " {") + x.g.P("return item[i]", fieldName, " < item[j]", fieldName) + x.g.P("}") + } + } + x.g.P("})") + x.g.P("return true") + x.g.P("})") + } + } + } +} + +func (x *Generator) GenOrderedIndexFinders() { + if !x.generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + indexContainerName := x.indexContainerName(index) + messagerName := x.messagerName() + x.g.P("// OrderedIndex: ", index.Index) + x.g.P() + + x.g.P("// Find", index.Name(), "Map finds the ordered index (", index.Index, ") to value (", x.mapValueType(index), ") treemap.") + x.g.P("// One key may correspond to multiple values, which are contained by a slice.") + x.g.P("func (x *", messagerName, ") Find", index.Name(), "Map() *", x.mapType(index), " {") + x.g.P("return x.", indexContainerName) + x.g.P("}") + x.g.P() + + keys := x.indexKeys(index) + params := keys.GenGetParams() + args := keys.GenGetArguments() + x.g.P("// Find", index.Name(), " finds a slice of all values of the given key.") + x.g.P("func (x *", messagerName, ") Find", index.Name(), "(", params, ") []*", x.mapValueType(index), " {") + if len(index.ColFields) == 1 { + x.g.P("val, _ := x.", indexContainerName, ".Get(", args, ")") + } else { + x.g.P("val, _ := x.", indexContainerName, ".Get(", x.mapKeyType(index), "{", args, "})") + } + x.g.P("return val") + x.g.P("}") + x.g.P() + + x.g.P("// FindFirst", index.Name(), " finds the first value of the given key,") + x.g.P("// or nil if no value found.") + x.g.P("func (x *", messagerName, ") FindFirst", index.Name(), "(", params, ") *", x.mapValueType(index), " {") + x.g.P("val := x.Find", index.Name(), "(", args, ")") + x.g.P("if len(val) > 0 {") + x.g.P("return val[0]") + x.g.P("}") + x.g.P("return nil") + x.g.P("}") + x.g.P() + } + } +} diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_map.go b/cmd/protoc-gen-go-tableau-loader/ordered_map.go deleted file mode 100644 index 707616ce..00000000 --- a/cmd/protoc-gen-go-tableau-loader/ordered_map.go +++ /dev/null @@ -1,202 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/iancoleman/strcase" - "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" - "github.com/tableauio/loader/internal/options" - "google.golang.org/protobuf/compiler/protogen" - "google.golang.org/protobuf/reflect/protoreflect" -) - -const orderedMapSuffix = "_OrderedMap" -const orderedMapValueSuffix = "_OrderedMapValue" - -var orderedMapTypeDefMap map[string]bool = make(map[string]bool) - -func genOrderedMapTypeDef(gen *protogen.Plugin, g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerName string) { - if depth == 1 && !options.NeedGenOrderedMap(md, options.LangGO) { - return - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - if depth == 1 { - g.P("// OrderedMap types.") - } - nextKeys := helper.AddMapKey(gen, fd, keys) - keyType := nextKeys[len(nextKeys)-1].Type - if keyType == "bool" { - keyType = "int" - } - if fd.MapValue().Kind() == protoreflect.MessageKind { - genOrderedMapTypeDef(gen, g, fd.MapValue().Message(), depth+1, nextKeys, messagerName) - } - prefix := parseOrderedMapPrefix(fd) - orderedMap := prefix + orderedMapSuffix - orderedMapValue := prefix + orderedMapValueSuffix - _, ok := orderedMapTypeDefMap[orderedMap] - if !ok { - orderedMapTypeDefMap[orderedMap] = true - nextMapFD := getNextLevelMapFD(fd.MapValue()) - if nextMapFD != nil { - currValueType := helper.FindMessageGoIdent(gen, fd.MapValue().Message()) - nextPrefix := parseOrderedMapPrefix(nextMapFD) - nextOrderedMap := nextPrefix + orderedMapSuffix - g.P("type ", orderedMapValue, "= ", pairPackage.Ident("Pair"), "[*", nextOrderedMap, ", *", currValueType, "];") - g.P("type ", orderedMap, "= ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", *", orderedMapValue, "]") - g.P() - } else { - g.P("type ", orderedMap, "= ", treeMapPackage.Ident("TreeMap"), "[", keyType, ", ", parseMapValueType(gen, g, fd), "]") - g.P() - } - } - return - } - } -} - -func genOrderedMapField(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor) { - if !options.NeedGenOrderedMap(md, options.LangGO) { - return - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - g.P("orderedMap *", parseOrderedMapPrefix(fd), orderedMapSuffix) - return - } - } -} - -func genOrderedMapLoader(gen *protogen.Plugin, g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerName string, lastOrderedMapValue string) { - if depth == 1 { - g.P("// OrderedMap init.") - } - message := helper.FindMessage(gen, md) - for _, field := range message.Fields { - fd := field.Desc - if fd.IsMap() { - needConvertBool := false - if len(keys) > 0 && keys[len(keys)-1].Type == "bool" { - needConvertBool = true - } - nextKeys := helper.AddMapKey(gen, fd, keys) - keyType := nextKeys[len(nextKeys)-1].Type - needConvertBoolNext := false - if keyType == "bool" { - keyType = "int" - needConvertBoolNext = true - } - prefix := parseOrderedMapPrefix(fd) - orderedMapValue := prefix + orderedMapValueSuffix - mapName := fmt.Sprintf("x.Data().Get%s()", field.GoName) - nextMapFD := getNextLevelMapFD(fd.MapValue()) - if depth == 1 { - if nextMapFD == nil { - g.P("x.orderedMap = ", treeMapPackage.Ident("New"), "[", keyType, ", ", parseMapValueType(gen, g, fd), "]()") - } else { - g.P("x.orderedMap = ", treeMapPackage.Ident("New"), "[", keyType, ", *", orderedMapValue, "]()") - } - } - if depth != 1 { - mapName = fmt.Sprintf("v%d.Get%s()", depth-1, field.GoName) - keyName := fmt.Sprintf("k%d", depth-1) - if needConvertBool { - keyName = fmt.Sprintf("BoolToInt(%s)", keyName) - } - g.P("k", depth-1, "v := &", lastOrderedMapValue, "{") - if nextMapFD == nil { - g.P("First: ", treeMapPackage.Ident("New"), "[", keyType, ", ", parseMapValueType(gen, g, fd), "](),") - } else { - g.P("First: ", treeMapPackage.Ident("New"), "[", keyType, ", *", orderedMapValue, "](),") - } - g.P("Second: v", depth-1, ",") - g.P("}") - g.P("map", depth-1, ".Put(", keyName, ", k", depth-1, "v)") - } - g.P("for k", depth, ", v", depth, " := range ", mapName, "{") - if depth == 1 { - g.P("map", depth, " := x.orderedMap") - } else { - g.P("map", depth, " := k", depth-1, "v.First") - } - if nextMapFD != nil { - genOrderedMapLoader(gen, g, fd.MapValue().Message(), depth+1, nextKeys, messagerName, orderedMapValue) - } else { - keyName := fmt.Sprintf("k%d", depth) - if needConvertBoolNext { - keyName = fmt.Sprintf("BoolToInt(%s)", keyName) - } - g.P("map", depth, ".Put(", keyName, ", v", depth, ")") - } - g.P("}") - break - } - } -} - -func genOrderedMapGetters(gen *protogen.Plugin, g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerName string) { - if depth == 1 && !options.NeedGenOrderedMap(md, options.LangGO) { - return - } - genGetterName := func(depth int) string { - getter := "GetOrderedMap" - if depth > 1 { - getter = fmt.Sprintf("GetOrderedMap%v", depth-1) - } - return getter - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - getter := genGetterName(depth) - prefix := parseOrderedMapPrefix(fd) - orderedMap := prefix + orderedMapSuffix - if depth == 1 { - g.P("// ", getter, " returns the 1-level ordered map.") - g.P("func (x *", messagerName, ") ", getter, "(", helper.GenGetParams(keys), ") *", orderedMap, "{") - g.P("return x.orderedMap ") - } else { - g.P("// ", getter, " finds value in the ", depth-1, "-level ordered map. It will return") - g.P("// NotFound error if the key is not found.") - g.P("func (x *", messagerName, ") ", getter, "(", helper.GenGetParams(keys), ") (*", orderedMap, ", error) {") - if depth == 2 { - g.P("conf := x.orderedMap") - } else { - prevKeys := keys[:len(keys)-1] - prevGetter := genGetterName(depth - 1) - g.P("conf, err := x.", prevGetter, "(", helper.GenGetArguments(prevKeys), ")") - g.P("if err != nil {") - g.P(`return nil, err`) - g.P("}") - } - lastKeyName := keys[len(keys)-1].Name - lastKeyType := keys[len(keys)-1].Type - keyName := lastKeyName - if lastKeyType == "bool" { - keyName = fmt.Sprintf("BoolToInt(%s)", keyName) - } - g.P("if val, ok := conf.Get(", keyName, "); !ok {") - g.P(`return nil, `, fmtPackage.Ident("Errorf"), `("`, lastKeyName, `(%v) %w", `, lastKeyName, `, ErrNotFound)`) - g.P("} else {") - g.P(`return val.First, nil`) - g.P("}") - - } - g.P("}") - g.P() - - nextKeys := helper.AddMapKey(gen, fd, keys) - if fd.MapValue().Kind() == protoreflect.MessageKind { - genOrderedMapGetters(gen, g, fd.MapValue().Message(), depth+1, nextKeys, messagerName) - } - break - } - } -} - -func parseOrderedMapPrefix(mapFd protoreflect.FieldDescriptor) string { - return strcase.ToCamel(string(mapFd.FullName())) -} diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go new file mode 100644 index 00000000..3792edbf --- /dev/null +++ b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go @@ -0,0 +1,248 @@ +package orderedmap + +import ( + "fmt" + + "github.com/iancoleman/strcase" + "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +var orderedMapTypeDefMap map[string]bool = make(map[string]bool) + +type Generator struct { + gen *protogen.Plugin + g *protogen.GeneratedFile + message *protogen.Message +} + +func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, message *protogen.Message) *Generator { + return &Generator{ + gen: gen, + g: g, + message: message, + } +} + +func (x *Generator) generate() bool { + return options.NeedGenOrderedMap(x.message.Desc, options.LangGO) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) mapType(mapFd protoreflect.FieldDescriptor) string { + return fmt.Sprintf("%s_OrderedMap", strcase.ToCamel(string(mapFd.FullName()))) +} + +func (x *Generator) mapValueType(mapFd protoreflect.FieldDescriptor) string { + return fmt.Sprintf("%s_OrderedMapValue", strcase.ToCamel(string(mapFd.FullName()))) +} + +func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + return "*" + x.mapValueType(fd) + } + return helper.ParseMapValueType(x.gen, x.g, fd) +} + +func (x *Generator) GenOrderedMapTypeDef() { + if !x.generate() { + return + } + x.g.P("// OrderedMap types.") + x.genOrderedMapTypeDef(x.message.Desc, 1, nil) +} + +func (x *Generator) genOrderedMapTypeDef(md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys) { + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + nextKeys := keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + keyType := nextKeys[len(nextKeys)-1].Type + if keyType == "bool" { + keyType = "int" + } + if fd.MapValue().Kind() == protoreflect.MessageKind { + x.genOrderedMapTypeDef(fd.MapValue().Message(), depth+1, nextKeys) + } + orderedMap := x.mapType(fd) + orderedMapValue := x.mapValueType(fd) + _, ok := orderedMapTypeDefMap[orderedMap] + if !ok { + orderedMapTypeDefMap[orderedMap] = true + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + currValueType := helper.FindMessageGoIdent(x.gen, fd.MapValue().Message()) + nextOrderedMap := x.mapType(nextMapFD) + x.g.P("type ", orderedMapValue, "= ", helper.PairPackage.Ident("Pair"), "[*", nextOrderedMap, ", *", currValueType, "];") + } + x.g.P("type ", orderedMap, "= ", helper.TreeMapPackage.Ident("TreeMap"), "[", keyType, ", ", x.mapValueFieldType(fd), "]") + x.g.P() + } + return + } + } +} + +func (x *Generator) GenOrderedMapField() { + if !x.generate() { + return + } + md := x.message.Desc + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + x.g.P("orderedMap *", x.mapType(fd)) + return + } + } +} + +func (x *Generator) GenOrderedMapLoader() { + if !x.generate() { + return + } + x.g.P("// OrderedMap init.") + x.genOrderedMapLoader(x.message.Desc, 1, nil, "") +} + +func (x *Generator) genOrderedMapLoader(md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys, lastOrderedMapValue string) { + message := helper.FindMessage(x.gen, md) + for _, field := range message.Fields { + fd := field.Desc + if fd.IsMap() { + needConvertBool := len(keys) > 0 && keys[len(keys)-1].Type == "int" + nextKeys := keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + keyType := nextKeys[len(nextKeys)-1].Type + needConvertBoolNext := keyType == "bool" + if keyType == "bool" { + keyType = "int" + } + orderedMapValue := x.mapValueType(fd) + mapName := fmt.Sprintf("x.Data().Get%s()", field.GoName) + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if depth == 1 { + x.g.P("x.orderedMap = ", helper.TreeMapPackage.Ident("New"), "[", keyType, ", ", x.mapValueFieldType(fd), "]()") + } + if depth != 1 { + mapName = fmt.Sprintf("v%d.Get%s()", depth-1, field.GoName) + keyName := fmt.Sprintf("k%d", depth-1) + if needConvertBool { + keyName = fmt.Sprintf("BoolToInt(%s)", keyName) + } + x.g.P("k", depth-1, "v := &", lastOrderedMapValue, "{") + x.g.P("First: ", helper.TreeMapPackage.Ident("New"), "[", keyType, ", ", x.mapValueFieldType(fd), "](),") + x.g.P("Second: v", depth-1, ",") + x.g.P("}") + x.g.P("map", depth-1, ".Put(", keyName, ", k", depth-1, "v)") + } + x.g.P("for k", depth, ", v", depth, " := range ", mapName, "{") + if depth == 1 { + x.g.P("map", depth, " := x.orderedMap") + } else { + x.g.P("map", depth, " := k", depth-1, "v.First") + } + if nextMapFD != nil { + x.genOrderedMapLoader(fd.MapValue().Message(), depth+1, nextKeys, orderedMapValue) + } else { + keyName := fmt.Sprintf("k%d", depth) + if needConvertBoolNext { + keyName = fmt.Sprintf("BoolToInt(%s)", keyName) + } + x.g.P("map", depth, ".Put(", keyName, ", v", depth, ")") + } + x.g.P("}") + break + } + } +} + +func (x *Generator) GenOrderedMapGetters() { + if !x.generate() { + return + } + x.genOrderedMapGetters(x.message.Desc, 1, nil) +} + +func (x *Generator) genOrderedMapGetters(md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys) { + genGetterName := func(depth int) string { + getter := "GetOrderedMap" + if depth > 1 { + getter = fmt.Sprintf("GetOrderedMap%v", depth-1) + } + return getter + } + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + getter := genGetterName(depth) + orderedMap := x.mapType(fd) + if depth == 1 { + x.g.P("// ", getter, " returns the 1-level ordered map.") + x.g.P("func (x *", x.messagerName(), ") ", getter, "(", keys.GenGetParams(), ") *", orderedMap, "{") + x.g.P("return x.orderedMap ") + } else { + x.g.P("// ", getter, " finds value in the ", depth-1, "-level ordered map. It will return") + x.g.P("// NotFound error if the key is not found.") + x.g.P("func (x *", x.messagerName(), ") ", getter, "(", keys.GenGetParams(), ") (*", orderedMap, ", error) {") + if depth == 2 { + x.g.P("conf := x.orderedMap") + } else { + prevKeys := keys[:len(keys)-1] + prevGetter := genGetterName(depth - 1) + x.g.P("conf, err := x.", prevGetter, "(", prevKeys.GenGetArguments(), ")") + x.g.P("if err != nil {") + x.g.P(`return nil, err`) + x.g.P("}") + } + lastKeyName := keys[len(keys)-1].Name + lastKeyType := keys[len(keys)-1].Type + keyName := lastKeyName + if lastKeyType == "int" { + keyName = fmt.Sprintf("BoolToInt(%s)", keyName) + } + x.g.P("if val, ok := conf.Get(", keyName, "); !ok {") + x.g.P(`return nil, `, helper.FmtPackage.Ident("Errorf"), `("`, lastKeyName, `(%v) %w", `, lastKeyName, `, ErrNotFound)`) + x.g.P("} else {") + x.g.P(`return val.First, nil`) + x.g.P("}") + + } + x.g.P("}") + x.g.P() + + nextKeys := keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + if fd.MapValue().Kind() == protoreflect.MessageKind { + x.genOrderedMapGetters(fd.MapValue().Message(), depth+1, nextKeys) + } + break + } + } +} + +func getNextLevelMapFD(fd protoreflect.FieldDescriptor) protoreflect.FieldDescriptor { + if fd.Kind() == protoreflect.MessageKind { + md := fd.Message() + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + return fd + } + } + } + return nil +} From 810d61b908468028024726e3d5248844c3e1a7e7 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Thu, 13 Nov 2025 21:16:48 +0800 Subject: [PATCH 3/8] feat: cpp --- .../helper/helper.go | 55 ++-- cmd/protoc-gen-cpp-tableau-loader/index.go | 291 ---------------- .../index/index.go | 311 ++++++++++++++++++ cmd/protoc-gen-cpp-tableau-loader/messager.go | 97 ++---- .../ordered_index.go | 190 ----------- .../ordered_index/ordered_index.go | 311 ++++++++++++++++++ .../ordered_map.go | 153 --------- .../ordered_map/ordered_map.go | 203 ++++++++++++ .../index/index.go | 9 +- .../ordered_index/ordered_index.go | 9 +- .../src/protoconf/item_conf.pc.cc | 84 ++++- .../src/protoconf/item_conf.pc.h | 113 +++++-- .../src/protoconf/test_conf.pc.cc | 36 +- .../src/protoconf/test_conf.pc.h | 77 +++-- 14 files changed, 1143 insertions(+), 796 deletions(-) delete mode 100644 cmd/protoc-gen-cpp-tableau-loader/index.go create mode 100644 cmd/protoc-gen-cpp-tableau-loader/index/index.go delete mode 100644 cmd/protoc-gen-cpp-tableau-loader/ordered_index.go create mode 100644 cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go delete mode 100644 cmd/protoc-gen-cpp-tableau-loader/ordered_map.go create mode 100644 cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go diff --git a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go index 2536c7f2..e606b93a 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go @@ -40,6 +40,17 @@ func protocVersion(gen *protogen.Plugin) string { return fmt.Sprintf("v%d.%d.%d%s", v.GetMajor(), v.GetMinor(), v.GetPatch(), suffix) } +func ParseMapFieldName(fd protoreflect.FieldDescriptor) string { + opts := fd.Options().(*descriptorpb.FieldOptions) + fdOpts := proto.GetExtension(opts, tableaupb.E_Field).(*tableaupb.FieldOptions) + name := fdOpts.GetKey() + if fd.MapValue().Kind() == protoreflect.MessageKind { + valueFd := fd.MapValue().Message().Fields().Get(0) + name = string(valueFd.Name()) + } + return escapeIdentifier(name) +} + func ParseIndexFieldName(fd protoreflect.FieldDescriptor) string { return escapeIdentifier(string(fd.Name())) } @@ -117,7 +128,7 @@ func ParseMapKeyType(fd protoreflect.FieldDescriptor) string { // fd must be an ordered type, or a message which can be converted to an ordered type. func ParseOrderedMapKeyType(fd protoreflect.FieldDescriptor) string { switch fd.Kind() { - case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.EnumKind: + case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return "int32_t" case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: return "uint32_t" @@ -131,6 +142,9 @@ func ParseOrderedMapKeyType(fd protoreflect.FieldDescriptor) string { return "double" case protoreflect.StringKind: return "std::string" + case protoreflect.EnumKind: + protoFullName := string(fd.Enum().FullName()) + return strings.ReplaceAll(protoFullName, ".", "::") case protoreflect.MessageKind: switch fd.Message().FullName() { case "google.protobuf.Timestamp", "google.protobuf.Duration": @@ -156,36 +170,31 @@ func ParseCppClassType(md protoreflect.MessageDescriptor) string { } type MapKey struct { - Type string - Name string + Type string + Name string + FieldName string } -func AddMapKey(fd protoreflect.FieldDescriptor, keys []MapKey) []MapKey { - opts := fd.Options().(*descriptorpb.FieldOptions) - fdOpts := proto.GetExtension(opts, tableaupb.E_Field).(*tableaupb.FieldOptions) - name := fdOpts.GetKey() - if fd.MapValue().Kind() == protoreflect.MessageKind { - valueFd := fd.MapValue().Message().Fields().Get(0) - name = string(valueFd.Name()) - } - name = escapeIdentifier(name) - if name == "" { - name = fmt.Sprintf("key%d", len(keys)+1) +type MapKeys []MapKey + +func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { + if newKey.Name == "" { + newKey.Name = fmt.Sprintf("key%d", len(keys)+1) } else { for _, key := range keys { - if key.Name == name { + if key.Name == newKey.Name { // rewrite to avoid name confict - name = fmt.Sprintf("%s%d", name, len(keys)+1) + newKey.Name = fmt.Sprintf("%s%d", newKey.Name, len(keys)+1) break } } } - keys = append(keys, MapKey{ParseMapKeyType(fd.MapKey()), name}) + keys = append(keys, newKey) return keys } // GenGetParams generates function parameters, which are the names listed in the function's definition. -func GenGetParams(keys []MapKey) string { +func (keys MapKeys) GenGetParams() string { var params string for i, key := range keys { params += ToConstRefType(key.Type) + " " + key.Name @@ -197,7 +206,7 @@ func GenGetParams(keys []MapKey) string { } // GenGetArguments generates function arguments, which are the real values passed to the function. -func GenGetArguments(keys []MapKey) string { +func (keys MapKeys) GenGetArguments() string { var params string for i, key := range keys { params += key.Name @@ -211,3 +220,11 @@ func GenGetArguments(keys []MapKey) string { func Indent(depth int) string { return strings.Repeat(" ", depth) } + +func ParseMapValueType(fd protoreflect.FieldDescriptor) string { + valueType := ParseCppType(fd.MapValue()) + if fd.MapValue().Kind() == protoreflect.MessageKind { + return "const " + valueType + "*" + } + return valueType +} diff --git a/cmd/protoc-gen-cpp-tableau-loader/index.go b/cmd/protoc-gen-cpp-tableau-loader/index.go deleted file mode 100644 index 8021f145..00000000 --- a/cmd/protoc-gen-cpp-tableau-loader/index.go +++ /dev/null @@ -1,291 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/iancoleman/strcase" - "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" - "github.com/tableauio/loader/internal/index" - "google.golang.org/protobuf/compiler/protogen" -) - -func genHppIndexFinders(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - g.P(helper.Indent(1), "// Index accessers.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take first field - g.P(helper.Indent(1), "// Index: ", index.Index) - g.P(" public:") - vectorType := fmt.Sprintf("Index_%sVector", index.Name()) - mapType := fmt.Sprintf("Index_%sMap", index.Name()) - g.P(helper.Indent(1), "using ", vectorType, " = std::vector;") - keyType := helper.ParseCppType(field.FD) - g.P(helper.Indent(1), "using ", mapType, " = std::unordered_map<", keyType, ", ", vectorType, ">;") - g.P(helper.Indent(1), "// Finds the index (", index.Index, ") to value (", vectorType, ") hash map.") - g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") - g.P(helper.Indent(1), "// Finds a vector of all values of the given key.") - g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", helper.ToConstRefType(keyType), " ", helper.ParseIndexFieldNameAsFuncParam(field.FD), ") const;") - g.P(helper.Indent(1), "// Finds the first value of the given key.") - g.P(helper.Indent(1), "const ", helper.ParseCppClassType(index.MD), "* FindFirst", index.Name(), "(", helper.ToConstRefType(keyType), " ", helper.ParseIndexFieldNameAsFuncParam(field.FD), ") const;") - g.P() - - g.P(" private:") - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(1), mapType, " ", indexContainerName, ";") - g.P() - } else { - // multi-column index - g.P(helper.Indent(1), "// Index: ", index.Index) - g.P(" public:") - keyType := fmt.Sprintf("Index_%sKey", index.Name()) - keyHasherType := fmt.Sprintf("Index_%sKeyHasher", index.Name()) - vectorType := fmt.Sprintf("Index_%sVector", index.Name()) - mapType := fmt.Sprintf("Index_%sMap", index.Name()) - - // generate key struct - g.P(helper.Indent(1), "struct ", keyType, " {") - var keys []helper.MapKey - equality := "" - for i, field := range index.ColFields { - typ := helper.ParseCppType(field.FD) - keys = append(keys, helper.MapKey{ - Type: typ, - Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), - }) - g.P(helper.Indent(2), typ, " ", helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD), ";") - equality += helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD) + " == other." + helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD) - if i != len(index.ColFields)-1 { - equality += " && " - } - } - g.P(helper.Indent(2), "bool operator==(const ", keyType, "& other) const {") - g.P(helper.Indent(3), "return ", equality, ";") - g.P(helper.Indent(2), "}") - g.P(helper.Indent(1), "};") - - // generate key hasher struct - g.P(helper.Indent(1), "struct ", keyHasherType, " {") - combinedKeys := "" - for i, field := range index.ColFields { - key := "key." + helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD) - combinedKeys += key - if i != len(index.ColFields)-1 { - combinedKeys += ", " - } - } - g.P(helper.Indent(2), "std::size_t operator()(const ", keyType, "& key) const {") - g.P(helper.Indent(3), "return util::SugaredHashCombine(", combinedKeys, ");") - g.P(helper.Indent(2), "}") - g.P(helper.Indent(1), "};") - - g.P(helper.Indent(1), "using ", vectorType, " = std::vector;") - g.P(helper.Indent(1), "using ", mapType, " = std::unordered_map<", keyType, ", ", vectorType, ", ", keyHasherType, ">;") - g.P(helper.Indent(1), "// Finds the index (", index.Index, ") to value (", vectorType, ") hash map.") - g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") - g.P(helper.Indent(1), "// Finds a vector of all values of the given keys.") - g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", helper.GenGetParams(keys), ") const;") - g.P(helper.Indent(1), "// Finds the first value of the given keys.") - g.P(helper.Indent(1), "const ", helper.ParseCppClassType(index.MD), "* FindFirst", index.Name(), "(", helper.GenGetParams(keys), ") const;") - g.P() - - g.P(" private:") - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(1), mapType, " ", indexContainerName, ";") - g.P() - } - } - } -} - -func genCppIndexLoader(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - g.P(helper.Indent(1), "// Index init.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(1), indexContainerName, ".clear();") - } - } - parentDataName := "data_" - depth := 1 - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - genOneCppIndexLoader(g, depth, index, parentDataName) - } - itemName := fmt.Sprintf("item%d", depth) - if levelMessage.FD == nil { - break - } - if !levelMessage.NextLevel.NeedGen() { - break - } - g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", parentDataName, ".", helper.ParseIndexFieldName(levelMessage.FD), "()) {") - parentDataName = itemName - if levelMessage.FD.IsMap() { - parentDataName = itemName + ".second" - } - depth++ - } - for i := depth - 1; i > 0; i-- { - g.P(helper.Indent(i), "}") - } - genIndexSorter(g, descriptor) -} - -func genOneCppIndexLoader(g *protogen.GeneratedFile, depth int, index *index.LevelIndex, parentDataName string) { - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(depth), "{") - g.P(helper.Indent(depth+1), "// Index: ", index.Index) - if len(index.ColFields) == 1 { - // single-column index - field := index.ColFields[0] // just take the first field - if field.FD.IsList() { - itemName := fmt.Sprintf("item%d", depth) - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - } - g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") - key := itemName - if field.FD.Enum() != nil { - key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" - } - g.P(helper.Indent(depth+2), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") - g.P(helper.Indent(depth+1), "}") - } else { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - } - key := parentDataName + fieldName - g.P(helper.Indent(depth+1), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") - } - } else { - // multi-column index - generateOneCppMulticolumnIndex(g, depth, index, parentDataName, nil) - } - g.P(helper.Indent(depth), "}") -} - -func genIndexSorter(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - if len(index.SortedColFields) != 0 { - g.P(helper.Indent(1), "// Index(sort): ", index.Index) - g.P(helper.Indent(1), "for (auto&& item : ", indexContainerName, ") {") - g.P(helper.Indent(2), "std::sort(item.second.begin(), item.second.end(),") - g.P(helper.Indent(7), "[](const ", helper.ParseCppClassType(index.MD), "* a, const ", helper.ParseCppClassType(index.MD), "* b) {") - for i, field := range index.SortedColFields { - fieldName := "" - for i, leveledFd := range field.LeveledFDList { - accessOperator := "." - if i == 0 { - accessOperator = "->" - } - fieldName += accessOperator + helper.ParseIndexFieldName(leveledFd) + "()" - } - if i == len(index.SortedColFields)-1 { - g.P(helper.Indent(8), "return a", fieldName, " < b", fieldName, ";") - } else { - g.P(helper.Indent(8), "if (a", fieldName, " != b", fieldName, ") {") - g.P(helper.Indent(9), "return a", fieldName, " < b", fieldName, ";") - g.P(helper.Indent(8), "}") - } - } - g.P(helper.Indent(7), "});") - g.P(helper.Indent(1), "}") - } - } - } -} - -func generateOneCppMulticolumnIndex(g *protogen.GeneratedFile, depth int, index *index.LevelIndex, parentDataName string, keys []string) []string { - cursor := len(keys) - if cursor >= len(index.ColFields) { - var keyParams string - for i, key := range keys { - keyParams += key - if i != len(keys)-1 { - keyParams += ", " - } - } - keyType := fmt.Sprintf("Index_%sKey", index.Name()) - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(depth+1), keyType, " key{", keyParams, "};") - g.P(helper.Indent(depth+1), indexContainerName, "[key].push_back(&", parentDataName, ");") - return keys - } - field := index.ColFields[cursor] - if field.FD.IsList() { - itemName := fmt.Sprintf("index_item%d", cursor) - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - } - g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") - key := itemName - if field.FD.Enum() != nil { - key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" - } - keys = append(keys, key) - keys = generateOneCppMulticolumnIndex(g, depth+1, index, parentDataName, keys) - g.P(helper.Indent(depth+1), "}") - } else { - fieldName := "" - for _, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - } - key := parentDataName + fieldName - keys = append(keys, key) - keys = generateOneCppMulticolumnIndex(g, depth, index, parentDataName, keys) - } - return keys -} - -func genCppIndexFinders(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.Indexes { - vectorType := "Index_" + index.Name() + "Vector" - mapType := "Index_" + index.Name() + "Map" - indexContainerName := "index_" + strcase.ToSnake(index.Name()) + "_map_" - - g.P("// Index: ", index.Index) - g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "Map() const { return ", indexContainerName, " ;}") - g.P() - - var keys []helper.MapKey - for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ - Type: helper.ParseCppType(field.FD), - Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), - }) - } - - g.P("const ", messagerName, "::", vectorType, "* ", messagerName, "::Find", index.Name(), "(", helper.GenGetParams(keys), ") const {") - if len(index.ColFields) == 1 { - g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find(", helper.GenGetArguments(keys), ");") - } else { - g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find({", helper.GenGetArguments(keys), "});") - } - g.P(helper.Indent(1), "if (iter == ", indexContainerName, ".end()) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "return &iter->second;") - g.P("}") - g.P() - - g.P("const ", helper.ParseCppClassType(index.MD), "* ", messagerName, "::FindFirst", index.Name(), "(", helper.GenGetParams(keys), ") const {") - g.P(helper.Indent(1), "auto conf = Find", index.Name(), "(", helper.GenGetArguments(keys), ");") - g.P(helper.Indent(1), "if (conf == nullptr || conf->empty()) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "return conf->front();") - g.P("}") - g.P() - } - } -} diff --git a/cmd/protoc-gen-cpp-tableau-loader/index/index.go b/cmd/protoc-gen-cpp-tableau-loader/index/index.go new file mode 100644 index 00000000..704352c9 --- /dev/null +++ b/cmd/protoc-gen-cpp-tableau-loader/index/index.go @@ -0,0 +1,311 @@ +package index + +import ( + "fmt" + "strings" + + "github.com/iancoleman/strcase" + "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" + "github.com/tableauio/loader/internal/index" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +type Generator struct { + g *protogen.GeneratedFile + descriptor *index.IndexDescriptor + message *protogen.Message +} + +func NewGenerator(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, message *protogen.Message) *Generator { + return &Generator{ + g: g, + descriptor: descriptor, + message: message, + } +} + +func (x *Generator) Generate() bool { + return options.NeedGenIndex(x.message.Desc, options.LangCPP) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) mapType(index *index.LevelIndex) string { + return fmt.Sprintf("Index_%sMap", index.Name()) +} + +func (x *Generator) mapKeyType(index *index.LevelIndex) string { + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + return helper.ParseCppType(field.FD) + } else { + // multi-column index + return fmt.Sprintf("Index_%sKey", index.Name()) + } +} + +func (x *Generator) mapValueType(index *index.LevelIndex) string { + return helper.ParseCppClassType(index.MD) +} + +func (x *Generator) mapValueVectorType(index *index.LevelIndex) string { + return fmt.Sprintf("Index_%sVector", index.Name()) +} + +func (x *Generator) indexContainerName(index *index.LevelIndex) string { + return fmt.Sprintf("index_%s_map_", strcase.ToSnake(index.Name())) +} + +func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { + var keys []helper.MapKey + for _, field := range index.ColFields { + keys = append(keys, helper.MapKey{ + Type: helper.ParseCppType(field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), + FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD), + }) + } + return keys +} + +func (x *Generator) fieldGetter(fd protoreflect.FieldDescriptor) string { + return fmt.Sprintf(".%s()", helper.ParseIndexFieldName(fd)) +} + +func (x *Generator) parseKeyFieldName(field *index.LevelField) string { + var fieldName string + for _, leveledFd := range field.LeveledFDList { + fieldName += x.fieldGetter(leveledFd) + } + return fieldName +} + +func (x *Generator) GenHppIndexFinders() { + if !x.Generate() { + return + } + x.g.P() + x.g.P(helper.Indent(1), "// Index accessers.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.g.P(helper.Indent(1), "// Index: ", index.Index) + x.g.P(" public:") + mapType := x.mapType(index) + keyType := x.mapKeyType(index) + vectorType := x.mapValueVectorType(index) + valueType := x.mapValueType(index) + keys := x.indexKeys(index) + hasher := "" // std::hash by default + if len(index.ColFields) != 1 { + // multi-column index + keyHasherType := fmt.Sprintf("Index_%sKeyHasher", index.Name()) + hasher = ", " + keyHasherType + // Generate key struct + x.g.P(helper.Indent(1), "struct ", keyType, " {") + var equalities []string + for _, key := range keys { + x.g.P(helper.Indent(2), key.Type, " ", key.FieldName, ";") + equalities = append(equalities, key.FieldName+" == other."+key.FieldName) + } + x.g.P("#if __cplusplus >= 202002L") + x.g.P(helper.Indent(2), "bool operator==(const ", keyType, "& other) const = default;") + x.g.P("#else") + x.g.P(helper.Indent(2), "bool operator==(const ", keyType, "& other) const {") + x.g.P(helper.Indent(3), "return ", strings.Join(equalities, " && "), ";") + x.g.P(helper.Indent(2), "}") + x.g.P("#endif") + x.g.P(helper.Indent(1), "};") + + // Generate key hasher struct + x.g.P(helper.Indent(1), "struct ", keyHasherType, " {") + var combinedKeys []string + for _, key := range keys { + combinedKeys = append(combinedKeys, "key."+key.FieldName) + } + x.g.P(helper.Indent(2), "std::size_t operator()(const ", keyType, "& key) const {") + x.g.P(helper.Indent(3), "return util::SugaredHashCombine(", strings.Join(combinedKeys, ", "), ");") + x.g.P(helper.Indent(2), "}") + x.g.P(helper.Indent(1), "};") + } + x.g.P(helper.Indent(1), "using ", vectorType, " = std::vector;") + x.g.P(helper.Indent(1), "using ", mapType, " = std::unordered_map<", keyType, ", ", vectorType, hasher, ">;") + x.g.P(helper.Indent(1), "// Finds the index (", index.Index, ") to value (", vectorType, ") hash map.") + x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") + x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") + x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") + x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") + x.g.P(helper.Indent(1), "const ", valueType, "* FindFirst", index.Name(), "(", keys.GenGetParams(), ") const;") + x.g.P() + x.g.P(" private:") + x.g.P(helper.Indent(1), mapType, " ", x.indexContainerName(index), ";") + x.g.P() + } + } +} + +func (x *Generator) GenCppIndexLoader() { + if !x.Generate() { + return + } + x.g.P(helper.Indent(1), "// Index init.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.g.P(helper.Indent(1), x.indexContainerName(index), ".clear();") + } + } + parentDataName := "data_" + depth := 1 + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + x.genOneCppIndexLoader(depth, index, parentDataName) + } + itemName := fmt.Sprintf("item%d", depth) + if levelMessage.FD == nil { + break + } + if !levelMessage.NextLevel.NeedGen() { + break + } + x.g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", parentDataName, x.fieldGetter(levelMessage.FD), ") {") + parentDataName = itemName + if levelMessage.FD.IsMap() { + parentDataName = itemName + ".second" + } + depth++ + } + for i := depth - 1; i > 0; i-- { + x.g.P(helper.Indent(i), "}") + } + x.genIndexSorter() +} + +func (x *Generator) genOneCppIndexLoader(depth int, index *index.LevelIndex, parentDataName string) { + x.g.P(helper.Indent(depth), "{") + x.g.P(helper.Indent(depth+1), "// Index: ", index.Index) + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take the first field + fieldName := x.parseKeyFieldName(field) + indexContainerName := x.indexContainerName(index) + if field.FD.IsList() { + itemName := fmt.Sprintf("item%d", depth) + x.g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") + key := itemName + if field.FD.Enum() != nil { + key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" + } + x.g.P(helper.Indent(depth+2), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") + x.g.P(helper.Indent(depth+1), "}") + } else { + key := parentDataName + fieldName + x.g.P(helper.Indent(depth+1), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") + } + } else { + // multi-column index + x.generateOneCppMulticolumnIndex(depth, index, parentDataName, nil) + } + x.g.P(helper.Indent(depth), "}") +} + +func (x *Generator) generateOneCppMulticolumnIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) { + cursor := len(keys) + if cursor >= len(index.ColFields) { + keyType := x.mapKeyType(index) + indexContainerName := x.indexContainerName(index) + x.g.P(helper.Indent(depth+1), keyType, " key{", keys.GenGetArguments(), "};") + x.g.P(helper.Indent(depth+1), indexContainerName, "[key].push_back(&", parentDataName, ");") + return + } + field := index.ColFields[cursor] + fieldName := x.parseKeyFieldName(field) + if field.FD.IsList() { + itemName := fmt.Sprintf("index_item%d", cursor) + x.g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") + key := itemName + if field.FD.Enum() != nil { + key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" + } + keys = append(keys, helper.MapKey{Name: key}) + x.generateOneCppMulticolumnIndex(depth+1, index, parentDataName, keys) + x.g.P(helper.Indent(depth+1), "}") + } else { + key := parentDataName + fieldName + keys = append(keys, helper.MapKey{Name: key}) + x.generateOneCppMulticolumnIndex(depth, index, parentDataName, keys) + } +} + +func (x *Generator) genIndexSorter() { + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + if len(index.SortedColFields) != 0 { + valueType := x.mapValueType(index) + x.g.P(helper.Indent(1), "// Index(sort): ", index.Index) + x.g.P(helper.Indent(1), "for (auto&& item : ", x.indexContainerName(index), ") {") + x.g.P(helper.Indent(2), "std::sort(item.second.begin(), item.second.end(),") + x.g.P(helper.Indent(7), "[](const ", valueType, "* a, const ", valueType, "* b) {") + for i, field := range index.SortedColFields { + fieldName := strings.Replace(x.parseKeyFieldName(field), ".", "->", 1) + if i == len(index.SortedColFields)-1 { + x.g.P(helper.Indent(8), "return a", fieldName, " < b", fieldName, ";") + } else { + x.g.P(helper.Indent(8), "if (a", fieldName, " != b", fieldName, ") {") + x.g.P(helper.Indent(9), "return a", fieldName, " < b", fieldName, ";") + x.g.P(helper.Indent(8), "}") + } + } + x.g.P(helper.Indent(7), "});") + x.g.P(helper.Indent(1), "}") + } + } + } +} + +func (x *Generator) GenCppIndexFinders() { + if !x.Generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.Indexes { + vectorType := x.mapValueVectorType(index) + mapType := x.mapType(index) + indexContainerName := x.indexContainerName(index) + messagerName := x.messagerName() + + x.g.P("// Index: ", index.Index) + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") + x.g.P() + + keys := x.indexKeys(index) + params := keys.GenGetParams() + args := keys.GenGetArguments() + x.g.P("const ", messagerName, "::", vectorType, "* ", messagerName, "::Find", index.Name(), "(", params, ") const {") + if len(index.ColFields) == 1 { + x.g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find(", args, ");") + } else { + x.g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find({", args, "});") + } + x.g.P(helper.Indent(1), "if (iter == ", indexContainerName, ".end()) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "return &iter->second;") + x.g.P("}") + x.g.P() + + x.g.P("const ", x.mapValueType(index), "* ", messagerName, "::FindFirst", index.Name(), "(", params, ") const {") + x.g.P(helper.Indent(1), "auto conf = Find", index.Name(), "(", args, ");") + x.g.P(helper.Indent(1), "if (conf == nullptr || conf->empty()) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "return conf->front();") + x.g.P("}") + x.g.P() + } + } +} diff --git a/cmd/protoc-gen-cpp-tableau-loader/messager.go b/cmd/protoc-gen-cpp-tableau-loader/messager.go index 7228a4fa..8c38dbbc 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/messager.go +++ b/cmd/protoc-gen-cpp-tableau-loader/messager.go @@ -4,9 +4,11 @@ import ( "strings" "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" + idx "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/index" + orderedindex "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/ordered_index" + orderedmap "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/ordered_map" "github.com/tableauio/loader/internal/extensions" "github.com/tableauio/loader/internal/index" - "github.com/tableauio/loader/internal/options" "github.com/tableauio/tableau/proto/tableaupb" "google.golang.org/protobuf/compiler/protogen" "google.golang.org/protobuf/proto" @@ -80,9 +82,12 @@ func generateHppFileContent(file *protogen.File, g *protogen.GeneratedFile) { // genHppMessage generates a message definition. func genHppMessage(g *protogen.GeneratedFile, message *protogen.Message) { cppFullName := helper.ParseCppClassType(message.Desc) - messagerFullName := string(message.Desc.FullName()) indexDescriptor := index.ParseIndexDescriptor(message.Desc) + orderedMapGenerator := orderedmap.NewGenerator(g, message) + indexGenerator := idx.NewGenerator(g, indexDescriptor, message) + orderedIndexGenerator := orderedindex.NewGenerator(g, indexDescriptor, message) + g.P("class ", message.Desc.Name(), " : public Messager {") g.P(" public:") g.P(helper.Indent(1), "static const std::string& Name() { return kProtoName; }") @@ -91,7 +96,7 @@ func genHppMessage(g *protogen.GeneratedFile, message *protogen.Message) { g.P(helper.Indent(1), "const google::protobuf::Message* Message() const override { return &data_; }") g.P() - if options.NeedGenOrderedMap(message.Desc, options.LangCPP) || options.NeedGenIndex(message.Desc, options.LangCPP) || options.NeedGenOrderedIndex(message.Desc, options.LangCPP) { + if orderedMapGenerator.Generate() || indexGenerator.Generate() || orderedIndexGenerator.Generate() { g.P(" private:") g.P(helper.Indent(1), "virtual bool ProcessAfterLoad() override final;") g.P() @@ -103,30 +108,25 @@ func genHppMessage(g *protogen.GeneratedFile, message *protogen.Message) { g.P(" private:") g.P(helper.Indent(1), "static const std::string kProtoName;") g.P(helper.Indent(1), cppFullName, " data_;") - if options.NeedGenOrderedMap(message.Desc, options.LangCPP) { - g.P() - genHppOrderedMapGetters(g, message.Desc, 1, nil, messagerFullName) - } - if options.NeedGenIndex(message.Desc, options.LangCPP) { - g.P() - genHppIndexFinders(g, indexDescriptor) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangCPP) { - genHppOrderedIndexFinders(g, indexDescriptor) - } + orderedMapGenerator.GenHppOrderedMapGetters() + indexGenerator.GenHppIndexFinders() + orderedIndexGenerator.GenHppOrderedIndexFinders() g.P("};") g.P() } -func genHppMapGetters(depth int, keys []helper.MapKey, g *protogen.GeneratedFile, md protoreflect.MessageDescriptor) { +func genHppMapGetters(depth int, keys helper.MapKeys, g *protogen.GeneratedFile, md protoreflect.MessageDescriptor) { for i := 0; i < md.Fields().Len(); i++ { fd := md.Fields().Get(i) if fd.IsMap() { if depth == 1 { g.P(" public:") } - keys = helper.AddMapKey(fd, keys) - g.P(helper.Indent(1), "const ", helper.ParseCppType(fd.MapValue()), "* Get(", helper.GenGetParams(keys), ") const;") + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + g.P(helper.Indent(1), "const ", helper.ParseCppType(fd.MapValue()), "* Get(", keys.GenGetParams(), ") const;") if fd.MapValue().Kind() == protoreflect.MessageKind { genHppMapGetters(depth+1, keys, g, fd.MapValue().Message()) } @@ -157,10 +157,13 @@ func generateCppFileContent(file *protogen.File, g *protogen.GeneratedFile) { // genCppMessage generates a message implementation. func genCppMessage(g *protogen.GeneratedFile, message *protogen.Message) { messagerName := string(message.Desc.Name()) - messagerFullName := string(message.Desc.FullName()) cppFullName := helper.ParseCppClassType(message.Desc) indexDescriptor := index.ParseIndexDescriptor(message.Desc) + orderedMapGenerator := orderedmap.NewGenerator(g, message) + indexGenerator := idx.NewGenerator(g, indexDescriptor, message) + orderedIndexGenerator := orderedindex.NewGenerator(g, indexDescriptor, message) + g.P("const std::string ", messagerName, "::kProtoName = ", cppFullName, `::GetDescriptor()->name();`) g.P() g.P("bool ", messagerName, "::Load(const std::filesystem::path& dir, Format fmt, std::shared_ptr options /* = nullptr */) {") @@ -172,17 +175,11 @@ func genCppMessage(g *protogen.GeneratedFile, message *protogen.Message) { g.P("}") g.P() - if options.NeedGenOrderedMap(message.Desc, options.LangCPP) || options.NeedGenIndex(message.Desc, options.LangCPP) || options.NeedGenOrderedIndex(message.Desc, options.LangCPP) { + if orderedMapGenerator.Generate() || indexGenerator.Generate() || orderedIndexGenerator.Generate() { g.P("bool ", messagerName, "::ProcessAfterLoad() {") - if options.NeedGenOrderedMap(message.Desc, options.LangCPP) { - genCppOrderedMapLoader(g, message.Desc, 1, messagerFullName) - } - if options.NeedGenIndex(message.Desc, options.LangCPP) { - genCppIndexLoader(g, indexDescriptor) - } - if options.NeedGenOrderedIndex(message.Desc, options.LangCPP) { - genCppOrderedIndexLoader(g, indexDescriptor) - } + orderedMapGenerator.GenOrderedMapLoader() + indexGenerator.GenCppIndexLoader() + orderedIndexGenerator.GenCppOrderedIndexLoader() g.P(helper.Indent(1), "return true;") g.P("}") g.P() @@ -190,23 +187,20 @@ func genCppMessage(g *protogen.GeneratedFile, message *protogen.Message) { // syntactic sugar for accessing map items genCppMapGetters(g, message.Desc, 1, nil, messagerName) - genCppOrderedMapGetters(g, message.Desc, 1, nil, messagerName, messagerFullName) - if options.NeedGenIndex(message.Desc, options.LangCPP) { - genCppIndexFinders(g, indexDescriptor, messagerName) - g.P() - } - if options.NeedGenOrderedIndex(message.Desc, options.LangCPP) { - genCppOrderedIndexFinders(g, indexDescriptor, messagerName) - g.P() - } + orderedMapGenerator.GenOrderedMapGetters() + indexGenerator.GenCppIndexFinders() + orderedIndexGenerator.GenCppOrderedIndexFinders() } -func genCppMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerName string) { +func genCppMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys, messagerName string) { for i := 0; i < md.Fields().Len(); i++ { fd := md.Fields().Get(i) if fd.IsMap() { - keys = helper.AddMapKey(fd, keys) - g.P("const ", helper.ParseCppType(fd.MapValue()), "* ", messagerName, "::Get(", helper.GenGetParams(keys), ") const {") + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + g.P("const ", helper.ParseCppType(fd.MapValue()), "* ", messagerName, "::Get(", keys.GenGetParams(), ") const {") var container string if depth == 1 { @@ -214,7 +208,7 @@ func genCppMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescript } else { container = "conf->" + string(fd.Name()) + "()" prevKeys := keys[:len(keys)-1] - g.P(helper.Indent(1), "const auto* conf = Get(", helper.GenGetArguments(prevKeys), ");") + g.P(helper.Indent(1), "const auto* conf = Get(", prevKeys.GenGetArguments(), ");") g.P(helper.Indent(1), "if (conf == nullptr) {") g.P(helper.Indent(2), "return nullptr;") g.P(helper.Indent(1), "}") @@ -235,24 +229,3 @@ func genCppMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescript } } } - -func getNextLevelMapFD(fd protoreflect.FieldDescriptor) protoreflect.FieldDescriptor { - if fd.Kind() == protoreflect.MessageKind { - md := fd.Message() - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - return fd - } - } - } - return nil -} - -func parseMapValueType(fd protoreflect.FieldDescriptor) string { - valueType := helper.ParseCppType(fd.MapValue()) - if fd.MapValue().Kind() == protoreflect.MessageKind { - return "const " + valueType + "*" - } - return valueType -} diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index.go deleted file mode 100644 index 6b675fc8..00000000 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_index.go +++ /dev/null @@ -1,190 +0,0 @@ -package main - -import ( - "fmt" - - "github.com/iancoleman/strcase" - "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" - "github.com/tableauio/loader/internal/index" - "google.golang.org/protobuf/compiler/protogen" -) - -func genHppOrderedIndexFinders(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - g.P(helper.Indent(1), "// OrderedIndex accessers.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - // single-column index - field := index.ColFields[0] // just take first field - g.P(helper.Indent(1), "// OrderedIndex: ", index.Index) - g.P(" public:") - vectorType := fmt.Sprintf("OrderedIndex_%sVector", index.Name()) - mapType := fmt.Sprintf("OrderedIndex_%sMap", index.Name()) - g.P(helper.Indent(1), "using ", vectorType, " = std::vector;") - keyType := helper.ParseOrderedMapKeyType(field.FD) - g.P(helper.Indent(1), "using ", mapType, " = std::map<", keyType, ", ", vectorType, ">;") - g.P(helper.Indent(1), "// Finds the ordered index (", index.Index, ") to value (", vectorType, ") hash map.") - g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") - g.P(helper.Indent(1), "// Finds a vector of all values of the given key.") - g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", helper.ToConstRefType(keyType), " ", helper.ParseIndexFieldNameAsFuncParam(field.FD), ") const;") - g.P(helper.Indent(1), "// Finds the first value of the given key.") - g.P(helper.Indent(1), "const ", helper.ParseCppClassType(index.MD), "* FindFirst", index.Name(), "(", helper.ToConstRefType(keyType), " ", helper.ParseIndexFieldNameAsFuncParam(field.FD), ") const;") - g.P() - - g.P(" private:") - indexContainerName := "ordered_index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(1), mapType, " ", indexContainerName, ";") - g.P() - } - } -} - -func genCppOrderedIndexLoader(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - g.P(helper.Indent(1), "// OrderedIndex init.") - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - indexContainerName := "ordered_index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(1), indexContainerName, ".clear();") - } - } - parentDataName := "data_" - depth := 1 - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - genOneCppOrderedIndexLoader(g, depth, index, parentDataName) - } - itemName := fmt.Sprintf("item%d", depth) - if levelMessage.FD == nil { - break - } - if !levelMessage.NextLevel.NeedGen() { - break - } - g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", parentDataName, ".", helper.ParseIndexFieldName(levelMessage.FD), "()) {") - parentDataName = itemName - if levelMessage.FD.IsMap() { - parentDataName = itemName + ".second" - } - depth++ - } - for i := depth - 1; i > 0; i-- { - g.P(helper.Indent(i), "}") - } - genOrderedIndexSorter(g, descriptor) -} - -func genOneCppOrderedIndexLoader(g *protogen.GeneratedFile, depth int, index *index.LevelIndex, parentDataName string) { - indexContainerName := "ordered_index_" + strcase.ToSnake(index.Name()) + "_map_" - g.P(helper.Indent(depth), "{") - g.P(helper.Indent(depth+1), "// OrderedIndex: ", index.Index) - // single-column index - field := index.ColFields[0] // just take the first field - if field.FD.IsList() { - itemName := fmt.Sprintf("item%d", depth) - fieldName := "" - suffix := "" - for i, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { - switch leveledFd.Message().FullName() { - case "google.protobuf.Timestamp", "google.protobuf.Duration": - suffix = ".seconds()" - default: - } - } - } - g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") - key := itemName + suffix - if field.FD.Enum() != nil { - key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" - } - g.P(helper.Indent(depth+2), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") - g.P(helper.Indent(depth+1), "}") - } else { - fieldName := "" - suffix := "" - for i, leveledFd := range field.LeveledFDList { - fieldName += "." + helper.ParseIndexFieldName(leveledFd) + "()" - if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { - switch leveledFd.Message().FullName() { - case "google.protobuf.Timestamp", "google.protobuf.Duration": - suffix = ".seconds()" - default: - } - } - } - key := parentDataName + fieldName + suffix - g.P(helper.Indent(depth+1), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") - } - g.P(helper.Indent(depth), "}") -} - -func genOrderedIndexSorter(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - indexContainerName := "ordered_index_" + strcase.ToSnake(index.Name()) + "_map_" - if len(index.SortedColFields) != 0 { - g.P(helper.Indent(1), "// OrderedIndex(sort): ", index.Index) - g.P(helper.Indent(1), "for (auto&& item : ", indexContainerName, ") {") - g.P(helper.Indent(2), "std::sort(item.second.begin(), item.second.end(),") - g.P(helper.Indent(7), "[](const ", helper.ParseCppClassType(index.MD), "* a, const ", helper.ParseCppClassType(index.MD), "* b) {") - for i, field := range index.SortedColFields { - fieldName := "" - for i, leveledFd := range field.LeveledFDList { - accessOperator := "." - if i == 0 { - accessOperator = "->" - } - fieldName += accessOperator + helper.ParseIndexFieldName(leveledFd) + "()" - } - if i == len(index.SortedColFields)-1 { - g.P(helper.Indent(8), "return a", fieldName, " < b", fieldName, ";") - } else { - g.P(helper.Indent(8), "if (a", fieldName, " != b", fieldName, ") {") - g.P(helper.Indent(9), "return a", fieldName, " < b", fieldName, ";") - g.P(helper.Indent(8), "}") - } - } - g.P(helper.Indent(7), "});") - g.P(helper.Indent(1), "}") - } - } - } -} - -func genCppOrderedIndexFinders(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, messagerName string) { - for levelMessage := descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { - for _, index := range levelMessage.OrderedIndexes { - vectorType := "OrderedIndex_" + index.Name() + "Vector" - mapType := "OrderedIndex_" + index.Name() + "Map" - indexContainerName := "ordered_index_" + strcase.ToSnake(index.Name()) + "_map_" - - g.P("// OrderedIndex: ", index.Index) - g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") - g.P() - - // single-column index - field := index.ColFields[0] // just take first field - keyType := helper.ParseOrderedMapKeyType(field.FD) - keyName := helper.ParseIndexFieldNameAsFuncParam(field.FD) - - g.P("const ", messagerName, "::", vectorType, "* ", messagerName, "::Find", index.Name(), "(", helper.ToConstRefType(keyType), " ", keyName, ") const {") - g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find(", keyName, ");") - g.P(helper.Indent(1), "if (iter == ", indexContainerName, ".end()) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "return &iter->second;") - g.P("}") - g.P() - - g.P("const ", helper.ParseCppClassType(index.MD), "* ", messagerName, "::FindFirst", index.Name(), "(", helper.ToConstRefType(keyType), " ", keyName, ") const {") - g.P(helper.Indent(1), "auto conf = Find", index.Name(), "(", keyName, ");") - g.P(helper.Indent(1), "if (conf == nullptr || conf->empty()) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "return conf->front();") - g.P("}") - g.P() - } - } -} diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go new file mode 100644 index 00000000..61cdf394 --- /dev/null +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go @@ -0,0 +1,311 @@ +package orderedindex + +import ( + "fmt" + "strings" + + "github.com/iancoleman/strcase" + "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" + "github.com/tableauio/loader/internal/index" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +type Generator struct { + g *protogen.GeneratedFile + descriptor *index.IndexDescriptor + message *protogen.Message +} + +func NewGenerator(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, message *protogen.Message) *Generator { + return &Generator{ + g: g, + descriptor: descriptor, + message: message, + } +} + +func (x *Generator) Generate() bool { + return options.NeedGenOrderedIndex(x.message.Desc, options.LangCPP) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) mapType(index *index.LevelIndex) string { + return fmt.Sprintf("OrderedIndex_%sMap", index.Name()) +} + +func (x *Generator) mapKeyType(index *index.LevelIndex) string { + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take first field + return helper.ParseOrderedMapKeyType(field.FD) + } else { + // multi-column index + return fmt.Sprintf("OrderedIndex_%sKey", index.Name()) + } +} + +func (x *Generator) mapValueType(index *index.LevelIndex) string { + return helper.ParseCppClassType(index.MD) +} + +func (x *Generator) mapValueVectorType(index *index.LevelIndex) string { + return fmt.Sprintf("OrderedIndex_%sVector", index.Name()) +} + +func (x *Generator) indexContainerName(index *index.LevelIndex) string { + return fmt.Sprintf("ordered_index_%s_map_", strcase.ToSnake(index.Name())) +} + +func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { + var keys []helper.MapKey + for _, field := range index.ColFields { + keys = append(keys, helper.MapKey{ + Type: helper.ParseOrderedMapKeyType(field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), + FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD), + }) + } + return keys +} + +func (x *Generator) fieldGetter(fd protoreflect.FieldDescriptor) string { + return fmt.Sprintf(".%s()", helper.ParseIndexFieldName(fd)) +} + +func (x *Generator) parseKeyFieldNameAndSuffix(field *index.LevelField) (string, string) { + var fieldName, suffix string + for i, leveledFd := range field.LeveledFDList { + fieldName += x.fieldGetter(leveledFd) + if i == len(field.LeveledFDList)-1 && leveledFd.Message() != nil { + switch leveledFd.Message().FullName() { + case "google.protobuf.Timestamp", "google.protobuf.Duration": + suffix = ".seconds()" + default: + } + } + } + return fieldName, suffix +} + +func (x *Generator) GenHppOrderedIndexFinders() { + if !x.Generate() { + return + } + x.g.P(helper.Indent(1), "// OrderedIndex accessers.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.g.P(helper.Indent(1), "// OrderedIndex: ", index.Index) + x.g.P(" public:") + mapType := x.mapType(index) + keyType := x.mapKeyType(index) + vectorType := x.mapValueVectorType(index) + valueType := x.mapValueType(index) + keys := x.indexKeys(index) + if len(index.ColFields) != 1 { + // multi-column index + // Generate key struct + x.g.P(helper.Indent(1), "struct ", keyType, " {") + for _, key := range keys { + x.g.P(helper.Indent(2), key.Type, " ", key.FieldName, ";") + } + x.g.P("#if __cplusplus >= 202002L") + x.g.P(helper.Indent(2), "auto operator<=>(const ", keyType, "& other) const = default;") + x.g.P("#else") + x.g.P(helper.Indent(2), "bool operator<(const ", keyType, "& other) const {") + for i, key := range keys { + if i == len(keys)-1 { + x.g.P(helper.Indent(3), "return ", key.FieldName, " < other.", key.FieldName, ";") + } else { + x.g.P(helper.Indent(3), "if (", key.FieldName, " != other.", key.FieldName, ") {") + x.g.P(helper.Indent(4), "return ", key.FieldName, " < other.", key.FieldName, ";") + x.g.P(helper.Indent(3), "}") + } + } + x.g.P(helper.Indent(2), "}") + x.g.P("#endif") + x.g.P(helper.Indent(1), "};") + } + x.g.P(helper.Indent(1), "using ", vectorType, " = std::vector;") + x.g.P(helper.Indent(1), "using ", mapType, " = std::map<", keyType, ", ", vectorType, ">;") + x.g.P(helper.Indent(1), "// Finds the ordered index (", index.Index, ") to value (", vectorType, ") map.") + x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") + x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") + x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") + x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") + x.g.P(helper.Indent(1), "const ", helper.ParseCppClassType(index.MD), "* FindFirst", index.Name(), "(", keys.GenGetParams(), ") const;") + x.g.P() + + x.g.P(" private:") + x.g.P(helper.Indent(1), mapType, " ", x.indexContainerName(index), ";") + x.g.P() + } + } +} + +func (x *Generator) GenCppOrderedIndexLoader() { + if !x.Generate() { + return + } + x.g.P(helper.Indent(1), "// OrderedIndex init.") + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.g.P(helper.Indent(1), x.indexContainerName(index), ".clear();") + } + } + parentDataName := "data_" + depth := 1 + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + x.genOneCppOrderedIndexLoader(depth, index, parentDataName) + } + itemName := fmt.Sprintf("item%d", depth) + if levelMessage.FD == nil { + break + } + if !levelMessage.NextLevel.NeedGen() { + break + } + x.g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", parentDataName, x.fieldGetter(levelMessage.FD), ") {") + parentDataName = itemName + if levelMessage.FD.IsMap() { + parentDataName = itemName + ".second" + } + depth++ + } + for i := depth - 1; i > 0; i-- { + x.g.P(helper.Indent(i), "}") + } + x.genOrderedIndexSorter() +} + +func (x *Generator) genOneCppOrderedIndexLoader(depth int, index *index.LevelIndex, parentDataName string) { + x.g.P(helper.Indent(depth), "{") + x.g.P(helper.Indent(depth+1), "// OrderedIndex: ", index.Index) + if len(index.ColFields) == 1 { + // single-column index + field := index.ColFields[0] // just take the first field + fieldName, suffix := x.parseKeyFieldNameAndSuffix(field) + indexContainerName := x.indexContainerName(index) + if field.FD.IsList() { + itemName := fmt.Sprintf("item%d", depth) + x.g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") + key := itemName + suffix + if field.FD.Enum() != nil { + key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" + } + x.g.P(helper.Indent(depth+2), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") + x.g.P(helper.Indent(depth+1), "}") + } else { + key := parentDataName + fieldName + suffix + x.g.P(helper.Indent(depth+1), indexContainerName, "[", key, "].push_back(&", parentDataName, ");") + } + } else { + // multi-column index + x.generateOneCppMulticolumnOrderedIndex(depth, index, parentDataName, nil) + } + x.g.P(helper.Indent(depth), "}") +} + +func (x *Generator) generateOneCppMulticolumnOrderedIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) { + cursor := len(keys) + if cursor >= len(index.ColFields) { + keyType := x.mapKeyType(index) + indexContainerName := x.indexContainerName(index) + x.g.P(helper.Indent(depth+1), keyType, " key{", keys.GenGetArguments(), "};") + x.g.P(helper.Indent(depth+1), indexContainerName, "[key].push_back(&", parentDataName, ");") + return + } + field := index.ColFields[cursor] + fieldName, suffix := x.parseKeyFieldNameAndSuffix(field) + if field.FD.IsList() { + itemName := fmt.Sprintf("index_item%d", cursor) + x.g.P(helper.Indent(depth+1), "for (auto&& ", itemName, " : ", parentDataName, fieldName, ") {") + key := itemName + suffix + if field.FD.Enum() != nil { + key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" + } + keys = append(keys, helper.MapKey{Name: key}) + x.generateOneCppMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) + x.g.P(helper.Indent(depth+1), "}") + } else { + key := parentDataName + fieldName + suffix + keys = append(keys, helper.MapKey{Name: key}) + x.generateOneCppMulticolumnOrderedIndex(depth, index, parentDataName, keys) + } +} + +func (x *Generator) genOrderedIndexSorter() { + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + if len(index.SortedColFields) != 0 { + valueType := x.mapValueType(index) + x.g.P(helper.Indent(1), "// OrderedIndex(sort): ", index.Index) + x.g.P(helper.Indent(1), "for (auto&& item : ", x.indexContainerName(index), ") {") + x.g.P(helper.Indent(2), "std::sort(item.second.begin(), item.second.end(),") + x.g.P(helper.Indent(7), "[](const ", valueType, "* a, const ", valueType, "* b) {") + for i, field := range index.SortedColFields { + fieldName, _ := x.parseKeyFieldNameAndSuffix(field) + fieldName = strings.Replace(fieldName, ".", "->", 1) + if i == len(index.SortedColFields)-1 { + x.g.P(helper.Indent(8), "return a", fieldName, " < b", fieldName, ";") + } else { + x.g.P(helper.Indent(8), "if (a", fieldName, " != b", fieldName, ") {") + x.g.P(helper.Indent(9), "return a", fieldName, " < b", fieldName, ";") + x.g.P(helper.Indent(8), "}") + } + } + x.g.P(helper.Indent(7), "});") + x.g.P(helper.Indent(1), "}") + } + } + } +} + +func (x *Generator) GenCppOrderedIndexFinders() { + if !x.Generate() { + return + } + for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { + for _, index := range levelMessage.OrderedIndexes { + vectorType := x.mapValueVectorType(index) + mapType := x.mapType(index) + indexContainerName := x.indexContainerName(index) + messagerName := x.messagerName() + + x.g.P("// OrderedIndex: ", index.Index) + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") + x.g.P() + + keys := x.indexKeys(index) + params := keys.GenGetParams() + args := keys.GenGetArguments() + x.g.P("const ", messagerName, "::", vectorType, "* ", messagerName, "::Find", index.Name(), "(", params, ") const {") + if len(index.ColFields) == 1 { + x.g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find(", args, ");") + } else { + x.g.P(helper.Indent(1), "auto iter = ", indexContainerName, ".find({", args, "});") + } + x.g.P(helper.Indent(1), "if (iter == ", indexContainerName, ".end()) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "return &iter->second;") + x.g.P("}") + x.g.P() + + x.g.P("const ", x.mapValueType(index), "* ", messagerName, "::FindFirst", index.Name(), "(", params, ") const {") + x.g.P(helper.Indent(1), "auto conf = Find", index.Name(), "(", args, ");") + x.g.P(helper.Indent(1), "if (conf == nullptr || conf->empty()) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "return conf->front();") + x.g.P("}") + x.g.P() + } + } +} diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_map.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_map.go deleted file mode 100644 index 8c560e90..00000000 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_map.go +++ /dev/null @@ -1,153 +0,0 @@ -package main - -import ( - "fmt" - "strings" - - "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" - "github.com/tableauio/loader/internal/options" - "google.golang.org/protobuf/compiler/protogen" - "google.golang.org/protobuf/reflect/protoreflect" -) - -const orderedMapSuffix = "_OrderedMap" -const orderedMapValueSuffix = "_OrderedMapValue" - -func genHppOrderedMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerFullName string) { - if depth == 1 && !options.NeedGenOrderedMap(md, options.LangCPP) { - return - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - if depth == 1 { - g.P(helper.Indent(1), "// OrderedMap accessers.") - g.P(" public:") - } - nextKeys := helper.AddMapKey(fd, keys) - keyType := nextKeys[len(nextKeys)-1].Type - - if fd.MapValue().Kind() == protoreflect.MessageKind { - genHppOrderedMapGetters(g, fd.MapValue().Message(), depth+1, nextKeys, messagerFullName) - } - - prefix := parseOrderedMapPrefix(fd, messagerFullName) - orderedMap := prefix + orderedMapSuffix - orderedMapValue := prefix + orderedMapValueSuffix - - nextMapFD := getNextLevelMapFD(fd.MapValue()) - if nextMapFD != nil { - currValueType := helper.ParseCppType(fd.MapValue()) - nextPrefix := parseOrderedMapPrefix(nextMapFD, messagerFullName) - nextOrderedMap := nextPrefix + orderedMapSuffix - // nextOrderedMapValue := nextPrefix + orderedMapValueSuffix - g.P(helper.Indent(1), "using ", orderedMapValue, " = std::pair<", nextOrderedMap, ", const ", currValueType, "*>;") - g.P(helper.Indent(1), "using ", orderedMap, " = std::map<", keyType, ", ", orderedMapValue, ">;") - g.P(helper.Indent(1), "const ", orderedMap, "* GetOrderedMap(", helper.GenGetParams(keys), ") const;") - g.P() - } else { - g.P(helper.Indent(1), "using ", orderedMap, " = std::map<", keyType, ", ", parseMapValueType(fd), ">;") - g.P(helper.Indent(1), "const ", orderedMap, "* GetOrderedMap(", helper.GenGetParams(keys), ") const;") - g.P() - } - if depth == 1 { - g.P(" private:") - g.P(helper.Indent(1), orderedMap, " ordered_map_;") - } - break - } - } -} - -func genCppOrderedMapLoader(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, messagerFullName string) { - if depth == 1 { - g.P(helper.Indent(1), "// OrderedMap init.") - g.P(helper.Indent(1), "ordered_map_.clear();") - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - prefix := parseOrderedMapPrefix(fd, messagerFullName) - // orderedMap := prefix + orderedMapSuffix - orderedMapValue := prefix + orderedMapValueSuffix - itemName := fmt.Sprintf("item%d", depth) - - tmpOrderedMapName := fmt.Sprintf("ordered_map%d", depth) - - prevItemName := fmt.Sprintf("item%d", depth-1) - prevContainer := prevItemName + ".second" - prevTmpOrderedMapName := fmt.Sprintf("ordered_map%d", depth-1) - if depth == 1 { - prevContainer = "data_" - prevTmpOrderedMapName = "ordered_map_" - } - g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", prevContainer, ".", string(fd.Name()), "()) {") - nextMapFD := getNextLevelMapFD(fd.MapValue()) - if nextMapFD != nil { - nextPrefix := parseOrderedMapPrefix(nextMapFD, messagerFullName) - // nextMap := nextPrefix + mapSuffix - nextOrderedMap := nextPrefix + orderedMapSuffix - g.P(helper.Indent(depth+1), prevTmpOrderedMapName, "[", itemName, ".first] = ", orderedMapValue, "(", nextOrderedMap, "(), &", itemName, ".second);") - g.P(helper.Indent(depth+1), "auto&& ", tmpOrderedMapName, " = ", prevTmpOrderedMapName, "[", itemName, ".first].first;") - } else { - ref := "&" - if fd.MapValue().Kind() != protoreflect.MessageKind { - ref = "" // scalar value type just do value copy. - } - g.P(helper.Indent(depth+1), prevTmpOrderedMapName, "[", itemName, ".first] = ", ref, itemName, ".second;") - } - if fd.MapValue().Kind() == protoreflect.MessageKind { - genCppOrderedMapLoader(g, fd.MapValue().Message(), depth+1, messagerFullName) - } - g.P(helper.Indent(depth), "}") - break - } - } -} - -func genCppOrderedMapGetters(g *protogen.GeneratedFile, md protoreflect.MessageDescriptor, depth int, keys []helper.MapKey, messagerName, messagerFullName string) { - if depth == 1 && !options.NeedGenOrderedMap(md, options.LangCPP) { - return - } - for i := 0; i < md.Fields().Len(); i++ { - fd := md.Fields().Get(i) - if fd.IsMap() { - prefix := parseOrderedMapPrefix(fd, messagerFullName) - orderedMap := prefix + orderedMapSuffix - - g.P("const ", messagerName, "::", orderedMap, "* ", messagerName, "::GetOrderedMap(", helper.GenGetParams(keys), ") const {") - if depth == 1 { - g.P(helper.Indent(1), "return &ordered_map_; ") - } else { - lastKeyName := keys[len(keys)-1].Name - prevKeys := keys[:len(keys)-1] - g.P(helper.Indent(1), "const auto* conf = GetOrderedMap(", helper.GenGetArguments(prevKeys), ");") - g.P(helper.Indent(1), "if (conf == nullptr) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "auto iter = conf->find(", lastKeyName, ");") - g.P(helper.Indent(1), "if (iter == conf->end()) {") - g.P(helper.Indent(2), "return nullptr;") - g.P(helper.Indent(1), "}") - g.P(helper.Indent(1), "return &iter->second.first;") - - } - g.P("}") - g.P() - - keys = helper.AddMapKey(fd, keys) - if fd.MapValue().Kind() == protoreflect.MessageKind { - genCppOrderedMapGetters(g, fd.MapValue().Message(), depth+1, keys, messagerName, messagerFullName) - } - break - } - } -} - -func parseOrderedMapPrefix(mapFd protoreflect.FieldDescriptor, messagerFullName string) string { - if mapFd.MapValue().Kind() == protoreflect.MessageKind { - localMsgProtoName := strings.TrimPrefix(string(mapFd.MapValue().Message().FullName()), messagerFullName+".") - return strings.ReplaceAll(localMsgProtoName, ".", "_") - } - return mapFd.MapValue().Kind().String() -} diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go new file mode 100644 index 00000000..725b1ae0 --- /dev/null +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go @@ -0,0 +1,203 @@ +package orderedmap + +import ( + "fmt" + "strings" + + "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" + "github.com/tableauio/loader/internal/options" + "google.golang.org/protobuf/compiler/protogen" + "google.golang.org/protobuf/reflect/protoreflect" +) + +type Generator struct { + g *protogen.GeneratedFile + message *protogen.Message +} + +func NewGenerator(g *protogen.GeneratedFile, message *protogen.Message) *Generator { + return &Generator{ + g: g, + message: message, + } +} + +func (x *Generator) Generate() bool { + return options.NeedGenOrderedMap(x.message.Desc, options.LangCPP) +} + +func (x *Generator) messagerName() string { + return string(x.message.Desc.Name()) +} + +func (x *Generator) orderedMapPrefix(mapFd protoreflect.FieldDescriptor) string { + if mapFd.MapValue().Kind() == protoreflect.MessageKind { + localMsgProtoName := strings.TrimPrefix(string(mapFd.MapValue().Message().FullName()), string(x.message.Desc.FullName())+".") + return strings.ReplaceAll(localMsgProtoName, ".", "_") + } + return mapFd.MapValue().Kind().String() +} + +func (x *Generator) mapType(mapFd protoreflect.FieldDescriptor) string { + return fmt.Sprintf("%s_OrderedMap", x.orderedMapPrefix(mapFd)) +} + +func (x *Generator) mapValueType(mapFd protoreflect.FieldDescriptor) string { + return fmt.Sprintf("%s_OrderedMapValue", x.orderedMapPrefix(mapFd)) +} + +func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + return x.mapValueType(fd) + } + return helper.ParseMapValueType(fd) +} + +func (x *Generator) GenHppOrderedMapGetters() { + if !x.Generate() { + return + } + x.g.P() + x.g.P(helper.Indent(1), "// OrderedMap accessers.") + x.g.P(" public:") + x.genHppOrderedMapGetters(x.message.Desc, 1, nil) +} + +func (x *Generator) genHppOrderedMapGetters(md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys) { + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + nextKeys := keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + keyType := nextKeys[len(nextKeys)-1].Type + if fd.MapValue().Kind() == protoreflect.MessageKind { + x.genHppOrderedMapGetters(fd.MapValue().Message(), depth+1, nextKeys) + } + orderedMap := x.mapType(fd) + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + orderedMapValue := x.mapValueType(fd) + currValueType := helper.ParseCppType(fd.MapValue()) + nextOrderedMap := x.mapType(nextMapFD) + x.g.P(helper.Indent(1), "using ", orderedMapValue, " = std::pair<", nextOrderedMap, ", const ", currValueType, "*>;") + } + x.g.P(helper.Indent(1), "using ", orderedMap, " = std::map<", keyType, ", ", x.mapValueFieldType(fd), ">;") + x.g.P(helper.Indent(1), "const ", orderedMap, "* GetOrderedMap(", keys.GenGetParams(), ") const;") + x.g.P() + if depth == 1 { + x.g.P(" private:") + x.g.P(helper.Indent(1), orderedMap, " ordered_map_;") + } + return + } + } +} + +func (x *Generator) GenOrderedMapLoader() { + if !x.Generate() { + return + } + x.g.P(helper.Indent(1), "// OrderedMap init.") + x.g.P(helper.Indent(1), "ordered_map_.clear();") + x.genOrderedMapLoader(x.message.Desc, 1) +} + +func (x *Generator) genOrderedMapLoader(md protoreflect.MessageDescriptor, depth int) { + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + orderedMapValue := x.mapValueType(fd) + itemName := fmt.Sprintf("item%d", depth) + + tmpOrderedMapName := fmt.Sprintf("ordered_map%d", depth) + + prevItemName := fmt.Sprintf("item%d", depth-1) + prevContainer := prevItemName + ".second" + prevTmpOrderedMapName := fmt.Sprintf("ordered_map%d", depth-1) + if depth == 1 { + prevContainer = "data_" + prevTmpOrderedMapName = "ordered_map_" + } + x.g.P(helper.Indent(depth), "for (auto&& ", itemName, " : ", prevContainer, ".", string(fd.Name()), "()) {") + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + nextOrderedMap := x.mapType(nextMapFD) + x.g.P(helper.Indent(depth+1), prevTmpOrderedMapName, "[", itemName, ".first] = ", orderedMapValue, "(", nextOrderedMap, "(), &", itemName, ".second);") + x.g.P(helper.Indent(depth+1), "auto&& ", tmpOrderedMapName, " = ", prevTmpOrderedMapName, "[", itemName, ".first].first;") + } else { + ref := "&" + if fd.MapValue().Kind() != protoreflect.MessageKind { + ref = "" // scalar value type just do value copy. + } + x.g.P(helper.Indent(depth+1), prevTmpOrderedMapName, "[", itemName, ".first] = ", ref, itemName, ".second;") + } + if fd.MapValue().Kind() == protoreflect.MessageKind { + x.genOrderedMapLoader(fd.MapValue().Message(), depth+1) + } + x.g.P(helper.Indent(depth), "}") + break + } + } +} + +func (x *Generator) GenOrderedMapGetters() { + if !x.Generate() { + return + } + x.genOrderedMapGetters(x.message.Desc, 1, nil) +} + +func (x *Generator) genOrderedMapGetters(md protoreflect.MessageDescriptor, depth int, keys helper.MapKeys) { + messagerName := x.messagerName() + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + orderedMap := x.mapType(fd) + + x.g.P("const ", messagerName, "::", orderedMap, "* ", messagerName, "::GetOrderedMap(", keys.GenGetParams(), ") const {") + if depth == 1 { + x.g.P(helper.Indent(1), "return &ordered_map_; ") + } else { + lastKeyName := keys[len(keys)-1].Name + prevKeys := keys[:len(keys)-1] + x.g.P(helper.Indent(1), "const auto* conf = GetOrderedMap(", prevKeys.GenGetArguments(), ");") + x.g.P(helper.Indent(1), "if (conf == nullptr) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "auto iter = conf->find(", lastKeyName, ");") + x.g.P(helper.Indent(1), "if (iter == conf->end()) {") + x.g.P(helper.Indent(2), "return nullptr;") + x.g.P(helper.Indent(1), "}") + x.g.P(helper.Indent(1), "return &iter->second.first;") + + } + x.g.P("}") + x.g.P() + + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseMapKeyType(fd.MapKey()), + Name: helper.ParseMapFieldName(fd), + }) + if fd.MapValue().Kind() == protoreflect.MessageKind { + x.genOrderedMapGetters(fd.MapValue().Message(), depth+1, keys) + } + break + } + } +} + +func getNextLevelMapFD(fd protoreflect.FieldDescriptor) protoreflect.FieldDescriptor { + if fd.Kind() == protoreflect.MessageKind { + md := fd.Message() + for i := 0; i < md.Fields().Len(); i++ { + fd := md.Fields().Get(i) + if fd.IsMap() { + return fd + } + } + } + return nil +} diff --git a/cmd/protoc-gen-go-tableau-loader/index/index.go b/cmd/protoc-gen-go-tableau-loader/index/index.go index 83cdd69d..0b530b0f 100644 --- a/cmd/protoc-gen-go-tableau-loader/index/index.go +++ b/cmd/protoc-gen-go-tableau-loader/index/index.go @@ -178,14 +178,14 @@ func (x *Generator) genOneIndexLoader(index *index.LevelIndex, depth int, parent x.g.P("}") } -func (x *Generator) generateOneMulticolumnIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) helper.MapKeys { +func (x *Generator) generateOneMulticolumnIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) { cursor := len(keys) if cursor >= len(index.ColFields) { keyType := x.mapKeyType(index) indexContainerName := x.indexContainerName(index) x.g.P("key := ", keyType, " {", keys.GenGetArguments(), "}") x.g.P("x.", indexContainerName, "[key] = append(x.", indexContainerName, "[key], ", parentDataName, ")") - return keys + return } field := index.ColFields[cursor] fieldName := x.parseKeyFieldName(field) @@ -193,14 +193,13 @@ func (x *Generator) generateOneMulticolumnIndex(depth int, index *index.LevelInd itemName := fmt.Sprintf("indexItem%d", cursor) x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") keys = append(keys, helper.MapKey{Name: itemName}) - keys = x.generateOneMulticolumnIndex(depth+1, index, parentDataName, keys) + x.generateOneMulticolumnIndex(depth+1, index, parentDataName, keys) x.g.P("}") } else { key := parentDataName + fieldName keys = append(keys, helper.MapKey{Name: key}) - keys = x.generateOneMulticolumnIndex(depth, index, parentDataName, keys) + x.generateOneMulticolumnIndex(depth, index, parentDataName, keys) } - return keys } func (x *Generator) genIndexSorter() { diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go index 131abc3b..12063e8c 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go @@ -211,7 +211,7 @@ func (x *Generator) genOneOrderedIndexLoader(index *index.LevelIndex, depth int, x.g.P("}") } -func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) helper.MapKeys { +func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.LevelIndex, parentDataName string, keys helper.MapKeys) { cursor := len(keys) if cursor >= len(index.ColFields) { keyType := x.mapKeyType(index) @@ -219,7 +219,7 @@ func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.L x.g.P("key := ", keyType, " {", keys.GenGetArguments(), "}") x.g.P("value, _ := x.", indexContainerName, ".Get(key)") x.g.P("x.", indexContainerName, ".Put(key, append(value, ", parentDataName, "))") - return keys + return } field := index.ColFields[cursor] fieldName, suffix := x.parseKeyFieldNameAndSuffix(field) @@ -228,14 +228,13 @@ func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.L x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") key := itemName + suffix keys = append(keys, helper.MapKey{Name: key}) - keys = x.generateOneMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) + x.generateOneMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) x.g.P("}") } else { key := parentDataName + fieldName + suffix keys = append(keys, helper.MapKey{Name: key}) - keys = x.generateOneMulticolumnOrderedIndex(depth, index, parentDataName, keys) + x.generateOneMulticolumnOrderedIndex(depth, index, parentDataName, keys) } - return keys } func (x *Generator) genOrderedIndexSorter() { diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc index 027766d8..8abdc097 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc @@ -108,6 +108,33 @@ bool ItemConf::ProcessAfterLoad() { return a->use_effect().type() < b->use_effect().type(); }); } + // OrderedIndex init. + ordered_index_ext_type_map_.clear(); + ordered_index_param_ext_type_map_.clear(); + for (auto&& item1 : data_.item_map()) { + { + // OrderedIndex: ExtType@ExtType + for (auto&& item2 : item1.second.ext_type_list()) { + ordered_index_ext_type_map_[static_cast(item2)].push_back(&item1.second); + } + } + { + // OrderedIndex: (Param,ExtType)@ParamExtType + for (auto&& index_item0 : item1.second.param_list()) { + for (auto&& index_item1 : item1.second.ext_type_list()) { + OrderedIndex_ParamExtTypeKey key{index_item0, static_cast(index_item1)}; + ordered_index_param_ext_type_map_[key].push_back(&item1.second); + } + } + } + } + // OrderedIndex(sort): (Param,ExtType)@ParamExtType + for (auto&& item : ordered_index_param_ext_type_map_) { + std::sort(item.second.begin(), item.second.end(), + [](const protoconf::ItemConf::Item* a, const protoconf::ItemConf::Item* b) { + return a->id() < b->id(); + }); + } return true; } @@ -124,7 +151,7 @@ const ItemConf::Item_OrderedMap* ItemConf::GetOrderedMap() const { } // Index: Type -const ItemConf::Index_ItemMap& ItemConf::FindItemMap() const { return index_item_map_ ;} +const ItemConf::Index_ItemMap& ItemConf::FindItem() const { return index_item_map_ ;} const ItemConf::Index_ItemVector* ItemConf::FindItem(protoconf::FruitType type) const { auto iter = index_item_map_.find(type); @@ -143,7 +170,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItem(protoconf::FruitType ty } // Index: Param@ItemInfo -const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfoMap() const { return index_item_info_map_ ;} +const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfo() const { return index_item_info_map_ ;} const ItemConf::Index_ItemInfoVector* ItemConf::FindItemInfo(int32_t param) const { auto iter = index_item_info_map_.find(param); @@ -162,7 +189,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemInfo(int32_t param) cons } // Index: Default@ItemDefaultInfo -const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfoMap() const { return index_item_default_info_map_ ;} +const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfo() const { return index_item_default_info_map_ ;} const ItemConf::Index_ItemDefaultInfoVector* ItemConf::FindItemDefaultInfo(const std::string& default_) const { auto iter = index_item_default_info_map_.find(default_); @@ -181,7 +208,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemDefaultInfo(const std::s } // Index: ExtType@ItemExtInfo -const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfoMap() const { return index_item_ext_info_map_ ;} +const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfo() const { return index_item_ext_info_map_ ;} const ItemConf::Index_ItemExtInfoVector* ItemConf::FindItemExtInfo(protoconf::FruitType ext_type) const { auto iter = index_item_ext_info_map_.find(ext_type); @@ -200,7 +227,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemExtInfo(protoconf::Fruit } // Index: (ID,Name)@AwardItem -const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItemMap() const { return index_award_item_map_ ;} +const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItem() const { return index_award_item_map_ ;} const ItemConf::Index_AwardItemVector* ItemConf::FindAwardItem(uint32_t id, const std::string& name) const { auto iter = index_award_item_map_.find({id, name}); @@ -219,7 +246,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstAwardItem(uint32_t id, const } // Index: (ID,Type,Param,ExtType)@SpecialItem -const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItemMap() const { return index_special_item_map_ ;} +const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItem() const { return index_special_item_map_ ;} const ItemConf::Index_SpecialItemVector* ItemConf::FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const { auto iter = index_special_item_map_.find({id, type, param, ext_type}); @@ -238,7 +265,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstSpecialItem(uint32_t id, pro } // Index: PathDir@ItemPathDir -const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDirMap() const { return index_item_path_dir_map_ ;} +const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDir() const { return index_item_path_dir_map_ ;} const ItemConf::Index_ItemPathDirVector* ItemConf::FindItemPathDir(const std::string& dir) const { auto iter = index_item_path_dir_map_.find(dir); @@ -257,7 +284,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathDir(const std::strin } // Index: PathName@ItemPathName -const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathNameMap() const { return index_item_path_name_map_ ;} +const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathName() const { return index_item_path_name_map_ ;} const ItemConf::Index_ItemPathNameVector* ItemConf::FindItemPathName(const std::string& name) const { auto iter = index_item_path_name_map_.find(name); @@ -276,7 +303,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathName(const std::stri } // Index: PathFriendID@ItemPathFriendID -const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendIDMap() const { return index_item_path_friend_id_map_ ;} +const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendID() const { return index_item_path_friend_id_map_ ;} const ItemConf::Index_ItemPathFriendIDVector* ItemConf::FindItemPathFriendID(uint32_t id) const { auto iter = index_item_path_friend_id_map_.find(id); @@ -295,7 +322,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathFriendID(uint32_t id } // Index: UseEffectType@UseEffectType -const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectTypeMap() const { return index_use_effect_type_map_ ;} +const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectType() const { return index_use_effect_type_map_ ;} const ItemConf::Index_UseEffectTypeVector* ItemConf::FindUseEffectType(protoconf::UseEffect::Type type) const { auto iter = index_use_effect_type_map_.find(type); @@ -313,5 +340,42 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstUseEffectType(protoconf::Use return conf->front(); } +// OrderedIndex: ExtType@ExtType +const ItemConf::OrderedIndex_ExtTypeMap& ItemConf::FindExtType() const { return ordered_index_ext_type_map_ ;} + +const ItemConf::OrderedIndex_ExtTypeVector* ItemConf::FindExtType(protoconf::FruitType ext_type) const { + auto iter = ordered_index_ext_type_map_.find(ext_type); + if (iter == ordered_index_ext_type_map_.end()) { + return nullptr; + } + return &iter->second; +} + +const protoconf::ItemConf::Item* ItemConf::FindFirstExtType(protoconf::FruitType ext_type) const { + auto conf = FindExtType(ext_type); + if (conf == nullptr || conf->empty()) { + return nullptr; + } + return conf->front(); +} + +// OrderedIndex: (Param,ExtType)@ParamExtType +const ItemConf::OrderedIndex_ParamExtTypeMap& ItemConf::FindParamExtType() const { return ordered_index_param_ext_type_map_ ;} + +const ItemConf::OrderedIndex_ParamExtTypeVector* ItemConf::FindParamExtType(int32_t param, protoconf::FruitType ext_type) const { + auto iter = ordered_index_param_ext_type_map_.find({param, ext_type}); + if (iter == ordered_index_param_ext_type_map_.end()) { + return nullptr; + } + return &iter->second; +} + +const protoconf::ItemConf::Item* ItemConf::FindFirstParamExtType(int32_t param, protoconf::FruitType ext_type) const { + auto conf = FindParamExtType(param, ext_type); + if (conf == nullptr || conf->empty()) { + return nullptr; + } + return conf->front(); +} } // namespace tableau diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h index 812d81eb..45fff5fa 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h @@ -45,10 +45,10 @@ class ItemConf : public Messager { using Index_ItemMap = std::unordered_map; // Finds the index (Type) to value (Index_ItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemMap& FindItemMap() const; - // Finds a vector of all values of the given key. + const Index_ItemMap& FindItem() const; + // Finds a vector of all values of the given key(s). const Index_ItemVector* FindItem(protoconf::FruitType type) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItem(protoconf::FruitType type) const; private: @@ -60,10 +60,10 @@ class ItemConf : public Messager { using Index_ItemInfoMap = std::unordered_map; // Finds the index (Param@ItemInfo) to value (Index_ItemInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemInfoMap& FindItemInfoMap() const; - // Finds a vector of all values of the given key. + const Index_ItemInfoMap& FindItemInfo() const; + // Finds a vector of all values of the given key(s). const Index_ItemInfoVector* FindItemInfo(int32_t param) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemInfo(int32_t param) const; private: @@ -75,10 +75,10 @@ class ItemConf : public Messager { using Index_ItemDefaultInfoMap = std::unordered_map; // Finds the index (Default@ItemDefaultInfo) to value (Index_ItemDefaultInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemDefaultInfoMap& FindItemDefaultInfoMap() const; - // Finds a vector of all values of the given key. + const Index_ItemDefaultInfoMap& FindItemDefaultInfo() const; + // Finds a vector of all values of the given key(s). const Index_ItemDefaultInfoVector* FindItemDefaultInfo(const std::string& default_) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemDefaultInfo(const std::string& default_) const; private: @@ -90,10 +90,10 @@ class ItemConf : public Messager { using Index_ItemExtInfoMap = std::unordered_map; // Finds the index (ExtType@ItemExtInfo) to value (Index_ItemExtInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemExtInfoMap& FindItemExtInfoMap() const; - // Finds a vector of all values of the given key. + const Index_ItemExtInfoMap& FindItemExtInfo() const; + // Finds a vector of all values of the given key(s). const Index_ItemExtInfoVector* FindItemExtInfo(protoconf::FruitType ext_type) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemExtInfo(protoconf::FruitType ext_type) const; private: @@ -104,9 +104,13 @@ class ItemConf : public Messager { struct Index_AwardItemKey { uint32_t id; std::string name; +#if __cplusplus >= 202002L + bool operator==(const Index_AwardItemKey& other) const = default; +#else bool operator==(const Index_AwardItemKey& other) const { return id == other.id && name == other.name; } +#endif }; struct Index_AwardItemKeyHasher { std::size_t operator()(const Index_AwardItemKey& key) const { @@ -117,10 +121,10 @@ class ItemConf : public Messager { using Index_AwardItemMap = std::unordered_map; // Finds the index ((ID,Name)@AwardItem) to value (Index_AwardItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardItemMap& FindAwardItemMap() const; - // Finds a vector of all values of the given keys. + const Index_AwardItemMap& FindAwardItem() const; + // Finds a vector of all values of the given key(s). const Index_AwardItemVector* FindAwardItem(uint32_t id, const std::string& name) const; - // Finds the first value of the given keys. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstAwardItem(uint32_t id, const std::string& name) const; private: @@ -133,9 +137,13 @@ class ItemConf : public Messager { protoconf::FruitType type; int32_t param; protoconf::FruitType ext_type; +#if __cplusplus >= 202002L + bool operator==(const Index_SpecialItemKey& other) const = default; +#else bool operator==(const Index_SpecialItemKey& other) const { return id == other.id && type == other.type && param == other.param && ext_type == other.ext_type; } +#endif }; struct Index_SpecialItemKeyHasher { std::size_t operator()(const Index_SpecialItemKey& key) const { @@ -146,10 +154,10 @@ class ItemConf : public Messager { using Index_SpecialItemMap = std::unordered_map; // Finds the index ((ID,Type,Param,ExtType)@SpecialItem) to value (Index_SpecialItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_SpecialItemMap& FindSpecialItemMap() const; - // Finds a vector of all values of the given keys. + const Index_SpecialItemMap& FindSpecialItem() const; + // Finds a vector of all values of the given key(s). const Index_SpecialItemVector* FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const; - // Finds the first value of the given keys. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const; private: @@ -161,10 +169,10 @@ class ItemConf : public Messager { using Index_ItemPathDirMap = std::unordered_map; // Finds the index (PathDir@ItemPathDir) to value (Index_ItemPathDirVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathDirMap& FindItemPathDirMap() const; - // Finds a vector of all values of the given key. + const Index_ItemPathDirMap& FindItemPathDir() const; + // Finds a vector of all values of the given key(s). const Index_ItemPathDirVector* FindItemPathDir(const std::string& dir) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemPathDir(const std::string& dir) const; private: @@ -176,10 +184,10 @@ class ItemConf : public Messager { using Index_ItemPathNameMap = std::unordered_map; // Finds the index (PathName@ItemPathName) to value (Index_ItemPathNameVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathNameMap& FindItemPathNameMap() const; - // Finds a vector of all values of the given key. + const Index_ItemPathNameMap& FindItemPathName() const; + // Finds a vector of all values of the given key(s). const Index_ItemPathNameVector* FindItemPathName(const std::string& name) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemPathName(const std::string& name) const; private: @@ -191,10 +199,10 @@ class ItemConf : public Messager { using Index_ItemPathFriendIDMap = std::unordered_map; // Finds the index (PathFriendID@ItemPathFriendID) to value (Index_ItemPathFriendIDVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathFriendIDMap& FindItemPathFriendIDMap() const; - // Finds a vector of all values of the given key. + const Index_ItemPathFriendIDMap& FindItemPathFriendID() const; + // Finds a vector of all values of the given key(s). const Index_ItemPathFriendIDVector* FindItemPathFriendID(uint32_t id) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstItemPathFriendID(uint32_t id) const; private: @@ -206,15 +214,60 @@ class ItemConf : public Messager { using Index_UseEffectTypeMap = std::unordered_map; // Finds the index (UseEffectType@UseEffectType) to value (Index_UseEffectTypeVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_UseEffectTypeMap& FindUseEffectTypeMap() const; - // Finds a vector of all values of the given key. + const Index_UseEffectTypeMap& FindUseEffectType() const; + // Finds a vector of all values of the given key(s). const Index_UseEffectTypeVector* FindUseEffectType(protoconf::UseEffect::Type type) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ItemConf::Item* FindFirstUseEffectType(protoconf::UseEffect::Type type) const; private: Index_UseEffectTypeMap index_use_effect_type_map_; + // OrderedIndex accessers. + // OrderedIndex: ExtType@ExtType + public: + using OrderedIndex_ExtTypeVector = std::vector; + using OrderedIndex_ExtTypeMap = std::map; + // Finds the ordered index (ExtType@ExtType) to value (OrderedIndex_ExtTypeVector) map. + // One key may correspond to multiple values, which are contained by a vector. + const OrderedIndex_ExtTypeMap& FindExtType() const; + // Finds a vector of all values of the given key(s). + const OrderedIndex_ExtTypeVector* FindExtType(protoconf::FruitType ext_type) const; + // Finds the first value of the given key(s). + const protoconf::ItemConf::Item* FindFirstExtType(protoconf::FruitType ext_type) const; + + private: + OrderedIndex_ExtTypeMap ordered_index_ext_type_map_; + + // OrderedIndex: (Param,ExtType)@ParamExtType + public: + struct OrderedIndex_ParamExtTypeKey { + int32_t param; + protoconf::FruitType ext_type; +#if __cplusplus >= 202002L + auto operator<=>(const OrderedIndex_ParamExtTypeKey& other) const = default; +#else + bool operator<(const OrderedIndex_ParamExtTypeKey& other) const { + if (param != other.param) { + return param < other.param; + } + return ext_type < other.ext_type; + } +#endif + }; + using OrderedIndex_ParamExtTypeVector = std::vector; + using OrderedIndex_ParamExtTypeMap = std::map; + // Finds the ordered index ((Param,ExtType)@ParamExtType) to value (OrderedIndex_ParamExtTypeVector) map. + // One key may correspond to multiple values, which are contained by a vector. + const OrderedIndex_ParamExtTypeMap& FindParamExtType() const; + // Finds a vector of all values of the given key(s). + const OrderedIndex_ParamExtTypeVector* FindParamExtType(int32_t param, protoconf::FruitType ext_type) const; + // Finds the first value of the given key(s). + const protoconf::ItemConf::Item* FindFirstParamExtType(int32_t param, protoconf::FruitType ext_type) const; + + private: + OrderedIndex_ParamExtTypeMap ordered_index_param_ext_type_map_; + }; } // namespace tableau diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc index 86bb5765..9eb3c4c8 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc @@ -162,7 +162,7 @@ const ActivityConf::int32_OrderedMap* ActivityConf::GetOrderedMap(uint64_t activ } // Index: ActivityName -const ActivityConf::Index_ActivityMap& ActivityConf::FindActivityMap() const { return index_activity_map_ ;} +const ActivityConf::Index_ActivityMap& ActivityConf::FindActivity() const { return index_activity_map_ ;} const ActivityConf::Index_ActivityVector* ActivityConf::FindActivity(const std::string& activity_name) const { auto iter = index_activity_map_.find(activity_name); @@ -181,7 +181,7 @@ const protoconf::ActivityConf::Activity* ActivityConf::FindFirstActivity(const s } // Index: ChapterID -const ActivityConf::Index_ChapterMap& ActivityConf::FindChapterMap() const { return index_chapter_map_ ;} +const ActivityConf::Index_ChapterMap& ActivityConf::FindChapter() const { return index_chapter_map_ ;} const ActivityConf::Index_ChapterVector* ActivityConf::FindChapter(uint32_t chapter_id) const { auto iter = index_chapter_map_.find(chapter_id); @@ -200,7 +200,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstChapter } // Index: ChapterName@NamedChapter -const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapterMap() const { return index_named_chapter_map_ ;} +const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapter() const { return index_named_chapter_map_ ;} const ActivityConf::Index_NamedChapterVector* ActivityConf::FindNamedChapter(const std::string& chapter_name) const { auto iter = index_named_chapter_map_.find(chapter_name); @@ -219,7 +219,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstNamedCh } // Index: SectionItemID@Award -const ActivityConf::Index_AwardMap& ActivityConf::FindAwardMap() const { return index_award_map_ ;} +const ActivityConf::Index_AwardMap& ActivityConf::FindAward() const { return index_award_map_ ;} const ActivityConf::Index_AwardVector* ActivityConf::FindAward(uint32_t id) const { auto iter = index_award_map_.find(id); @@ -237,7 +237,6 @@ const protoconf::Section::SectionItem* ActivityConf::FindFirstAward(uint32_t id) return conf->front(); } - const std::string ChapterConf::kProtoName = protoconf::ChapterConf::GetDescriptor()->name(); bool ChapterConf::Load(const std::filesystem::path& dir, Format fmt, std::shared_ptr options /* = nullptr */) { @@ -319,6 +318,7 @@ bool TaskConf::ProcessAfterLoad() { ordered_index_ordered_task_map_.clear(); ordered_index_task_expiry_map_.clear(); ordered_index_sorted_task_expiry_map_.clear(); + ordered_index_activity_expiry_map_.clear(); for (auto&& item1 : data_.task_map()) { { // OrderedIndex: Goal@OrderedTask @@ -332,6 +332,11 @@ bool TaskConf::ProcessAfterLoad() { // OrderedIndex: Expiry@SortedTaskExpiry ordered_index_sorted_task_expiry_map_[item1.second.expiry().seconds()].push_back(&item1.second); } + { + // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry + OrderedIndex_ActivityExpiryKey key{item1.second.expiry().seconds(), item1.second.activity_id()}; + ordered_index_activity_expiry_map_[key].push_back(&item1.second); + } } // OrderedIndex(sort): Goal@OrderedTask for (auto&& item : ordered_index_ordered_task_map_) { @@ -362,7 +367,7 @@ const protoconf::TaskConf::Task* TaskConf::Get(int64_t id) const { } // Index: ActivityID -const TaskConf::Index_TaskMap& TaskConf::FindTaskMap() const { return index_task_map_ ;} +const TaskConf::Index_TaskMap& TaskConf::FindTask() const { return index_task_map_ ;} const TaskConf::Index_TaskVector* TaskConf::FindTask(int64_t activity_id) const { auto iter = index_task_map_.find(activity_id); @@ -380,7 +385,6 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstTask(int64_t activity_id) co return conf->front(); } - // OrderedIndex: Goal@OrderedTask const TaskConf::OrderedIndex_OrderedTaskMap& TaskConf::FindOrderedTask() const { return ordered_index_ordered_task_map_ ;} @@ -438,5 +442,23 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstSortedTaskExpiry(int64_t exp return conf->front(); } +// OrderedIndex: (Expiry,ActivityID)@ActivityExpiry +const TaskConf::OrderedIndex_ActivityExpiryMap& TaskConf::FindActivityExpiry() const { return ordered_index_activity_expiry_map_ ;} + +const TaskConf::OrderedIndex_ActivityExpiryVector* TaskConf::FindActivityExpiry(int64_t expiry, int64_t activity_id) const { + auto iter = ordered_index_activity_expiry_map_.find({expiry, activity_id}); + if (iter == ordered_index_activity_expiry_map_.end()) { + return nullptr; + } + return &iter->second; +} + +const protoconf::TaskConf::Task* TaskConf::FindFirstActivityExpiry(int64_t expiry, int64_t activity_id) const { + auto conf = FindActivityExpiry(expiry, activity_id); + if (conf == nullptr || conf->empty()) { + return nullptr; + } + return conf->front(); +} } // namespace tableau diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h index b3d6df19..ae635ce0 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h @@ -60,10 +60,10 @@ class ActivityConf : public Messager { using Index_ActivityMap = std::unordered_map; // Finds the index (ActivityName) to value (Index_ActivityVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ActivityMap& FindActivityMap() const; - // Finds a vector of all values of the given key. + const Index_ActivityMap& FindActivity() const; + // Finds a vector of all values of the given key(s). const Index_ActivityVector* FindActivity(const std::string& activity_name) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ActivityConf::Activity* FindFirstActivity(const std::string& activity_name) const; private: @@ -75,10 +75,10 @@ class ActivityConf : public Messager { using Index_ChapterMap = std::unordered_map; // Finds the index (ChapterID) to value (Index_ChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ChapterMap& FindChapterMap() const; - // Finds a vector of all values of the given key. + const Index_ChapterMap& FindChapter() const; + // Finds a vector of all values of the given key(s). const Index_ChapterVector* FindChapter(uint32_t chapter_id) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ActivityConf::Activity::Chapter* FindFirstChapter(uint32_t chapter_id) const; private: @@ -90,10 +90,10 @@ class ActivityConf : public Messager { using Index_NamedChapterMap = std::unordered_map; // Finds the index (ChapterName@NamedChapter) to value (Index_NamedChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_NamedChapterMap& FindNamedChapterMap() const; - // Finds a vector of all values of the given key. + const Index_NamedChapterMap& FindNamedChapter() const; + // Finds a vector of all values of the given key(s). const Index_NamedChapterVector* FindNamedChapter(const std::string& chapter_name) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::ActivityConf::Activity::Chapter* FindFirstNamedChapter(const std::string& chapter_name) const; private: @@ -105,10 +105,10 @@ class ActivityConf : public Messager { using Index_AwardMap = std::unordered_map; // Finds the index (SectionItemID@Award) to value (Index_AwardVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardMap& FindAwardMap() const; - // Finds a vector of all values of the given key. + const Index_AwardMap& FindAward() const; + // Finds a vector of all values of the given key(s). const Index_AwardVector* FindAward(uint32_t id) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::Section::SectionItem* FindFirstAward(uint32_t id) const; private: @@ -171,10 +171,10 @@ class TaskConf : public Messager { using Index_TaskMap = std::unordered_map; // Finds the index (ActivityID) to value (Index_TaskVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_TaskMap& FindTaskMap() const; - // Finds a vector of all values of the given key. + const Index_TaskMap& FindTask() const; + // Finds a vector of all values of the given key(s). const Index_TaskVector* FindTask(int64_t activity_id) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::TaskConf::Task* FindFirstTask(int64_t activity_id) const; private: @@ -185,12 +185,12 @@ class TaskConf : public Messager { public: using OrderedIndex_OrderedTaskVector = std::vector; using OrderedIndex_OrderedTaskMap = std::map; - // Finds the ordered index (Goal@OrderedTask) to value (OrderedIndex_OrderedTaskVector) hash map. + // Finds the ordered index (Goal@OrderedTask) to value (OrderedIndex_OrderedTaskVector) map. // One key may correspond to multiple values, which are contained by a vector. const OrderedIndex_OrderedTaskMap& FindOrderedTask() const; - // Finds a vector of all values of the given key. + // Finds a vector of all values of the given key(s). const OrderedIndex_OrderedTaskVector* FindOrderedTask(int64_t goal) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::TaskConf::Task* FindFirstOrderedTask(int64_t goal) const; private: @@ -200,12 +200,12 @@ class TaskConf : public Messager { public: using OrderedIndex_TaskExpiryVector = std::vector; using OrderedIndex_TaskExpiryMap = std::map; - // Finds the ordered index (Expiry@TaskExpiry) to value (OrderedIndex_TaskExpiryVector) hash map. + // Finds the ordered index (Expiry@TaskExpiry) to value (OrderedIndex_TaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. const OrderedIndex_TaskExpiryMap& FindTaskExpiry() const; - // Finds a vector of all values of the given key. + // Finds a vector of all values of the given key(s). const OrderedIndex_TaskExpiryVector* FindTaskExpiry(int64_t expiry) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::TaskConf::Task* FindFirstTaskExpiry(int64_t expiry) const; private: @@ -215,17 +215,46 @@ class TaskConf : public Messager { public: using OrderedIndex_SortedTaskExpiryVector = std::vector; using OrderedIndex_SortedTaskExpiryMap = std::map; - // Finds the ordered index (Expiry@SortedTaskExpiry) to value (OrderedIndex_SortedTaskExpiryVector) hash map. + // Finds the ordered index (Expiry@SortedTaskExpiry) to value (OrderedIndex_SortedTaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. const OrderedIndex_SortedTaskExpiryMap& FindSortedTaskExpiry() const; - // Finds a vector of all values of the given key. + // Finds a vector of all values of the given key(s). const OrderedIndex_SortedTaskExpiryVector* FindSortedTaskExpiry(int64_t expiry) const; - // Finds the first value of the given key. + // Finds the first value of the given key(s). const protoconf::TaskConf::Task* FindFirstSortedTaskExpiry(int64_t expiry) const; private: OrderedIndex_SortedTaskExpiryMap ordered_index_sorted_task_expiry_map_; + // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry + public: + struct OrderedIndex_ActivityExpiryKey { + int64_t expiry; + int64_t activity_id; +#if __cplusplus >= 202002L + auto operator<=>(const OrderedIndex_ActivityExpiryKey& other) const = default; +#else + bool operator<(const OrderedIndex_ActivityExpiryKey& other) const { + if (expiry != other.expiry) { + return expiry < other.expiry; + } + return activity_id < other.activity_id; + } +#endif + }; + using OrderedIndex_ActivityExpiryVector = std::vector; + using OrderedIndex_ActivityExpiryMap = std::map; + // Finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (OrderedIndex_ActivityExpiryVector) map. + // One key may correspond to multiple values, which are contained by a vector. + const OrderedIndex_ActivityExpiryMap& FindActivityExpiry() const; + // Finds a vector of all values of the given key(s). + const OrderedIndex_ActivityExpiryVector* FindActivityExpiry(int64_t expiry, int64_t activity_id) const; + // Finds the first value of the given key(s). + const protoconf::TaskConf::Task* FindFirstActivityExpiry(int64_t expiry, int64_t activity_id) const; + + private: + OrderedIndex_ActivityExpiryMap ordered_index_activity_expiry_map_; + }; } // namespace tableau From f11b8f975df4e8c48f93f4e82779f97c05b3b372 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Fri, 14 Nov 2025 20:30:29 +0800 Subject: [PATCH 4/8] feat: unify naming of generated structs --- .../index/index.go | 4 +- .../ordered_index/ordered_index.go | 4 +- .../ordered_map/ordered_map.go | 4 +- .../index/index.go | 4 +- .../ordered_index/ordered_index.go | 4 +- .../ordered_map/ordered_map.go | 34 ++--- test/cpp-tableau-loader/src/main.cpp | 5 +- .../src/protoconf/hero_conf.pc.cc | 6 +- .../src/protoconf/hero_conf.pc.h | 12 +- .../src/protoconf/item_conf.pc.cc | 26 ++-- .../src/protoconf/item_conf.pc.h | 30 ++--- .../src/protoconf/test_conf.pc.cc | 32 ++--- .../src/protoconf/test_conf.pc.h | 42 +++--- .../protoconf/loader/hero_conf.pc.go | 24 ++-- .../protoconf/loader/item_conf.pc.go | 122 +++++++++--------- .../protoconf/loader/test_conf.pc.go | 110 ++++++++-------- 16 files changed, 233 insertions(+), 230 deletions(-) diff --git a/cmd/protoc-gen-cpp-tableau-loader/index/index.go b/cmd/protoc-gen-cpp-tableau-loader/index/index.go index 704352c9..ead69ce0 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/index/index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/index/index.go @@ -136,7 +136,7 @@ func (x *Generator) GenHppIndexFinders() { x.g.P(helper.Indent(1), "using ", mapType, " = std::unordered_map<", keyType, ", ", vectorType, hasher, ">;") x.g.P(helper.Indent(1), "// Finds the index (", index.Index, ") to value (", vectorType, ") hash map.") x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") @@ -279,7 +279,7 @@ func (x *Generator) GenCppIndexFinders() { messagerName := x.messagerName() x.g.P("// Index: ", index.Index) - x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "Map() const { return ", indexContainerName, " ;}") x.g.P() keys := x.indexKeys(index) diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go index 61cdf394..e3538e34 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go @@ -134,7 +134,7 @@ func (x *Generator) GenHppOrderedIndexFinders() { x.g.P(helper.Indent(1), "using ", mapType, " = std::map<", keyType, ", ", vectorType, ">;") x.g.P(helper.Indent(1), "// Finds the ordered index (", index.Index, ") to value (", vectorType, ") map.") x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") @@ -279,7 +279,7 @@ func (x *Generator) GenCppOrderedIndexFinders() { messagerName := x.messagerName() x.g.P("// OrderedIndex: ", index.Index) - x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "Map() const { return ", indexContainerName, " ;}") x.g.P() keys := x.indexKeys(index) diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go index 725b1ae0..d3eab80c 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go @@ -39,11 +39,11 @@ func (x *Generator) orderedMapPrefix(mapFd protoreflect.FieldDescriptor) string } func (x *Generator) mapType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("%s_OrderedMap", x.orderedMapPrefix(mapFd)) + return fmt.Sprintf("OrderedMap_%sMap", x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("%s_OrderedMapValue", x.orderedMapPrefix(mapFd)) + return fmt.Sprintf("OrderedMap_%sValue", x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { diff --git a/cmd/protoc-gen-go-tableau-loader/index/index.go b/cmd/protoc-gen-go-tableau-loader/index/index.go index 0b530b0f..caf7930f 100644 --- a/cmd/protoc-gen-go-tableau-loader/index/index.go +++ b/cmd/protoc-gen-go-tableau-loader/index/index.go @@ -36,7 +36,7 @@ func (x *Generator) messagerName() string { } func (x *Generator) mapType(index *index.LevelIndex) string { - return fmt.Sprintf("%s_Index_%sMap", x.messagerName(), index.Name()) + return fmt.Sprintf("Index_%s_%sMap", x.messagerName(), index.Name()) } func (x *Generator) mapKeyType(index *index.LevelIndex) string { @@ -46,7 +46,7 @@ func (x *Generator) mapKeyType(index *index.LevelIndex) string { return helper.ParseGoType(x.gen, x.g, field.FD) } else { // multi-column index - return fmt.Sprintf("%s_Index_%sKey", x.messagerName(), index.Name()) + return fmt.Sprintf("Index_%s_%sKey", x.messagerName(), index.Name()) } } diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go index 12063e8c..56245c46 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go @@ -36,7 +36,7 @@ func (x *Generator) messagerName() string { } func (x *Generator) mapType(index *index.LevelIndex) string { - return fmt.Sprintf("%s_OrderedIndex_%sMap", x.messagerName(), index.Name()) + return fmt.Sprintf("OrderedIndex_%s_%sMap", x.messagerName(), index.Name()) } func (x *Generator) mapKeyType(index *index.LevelIndex) string { @@ -46,7 +46,7 @@ func (x *Generator) mapKeyType(index *index.LevelIndex) string { return helper.ParseOrderedMapKeyType(x.gen, x.g, field.FD) } else { // multi-column index - return fmt.Sprintf("%s_OrderedIndex_%sKey", x.messagerName(), index.Name()) + return fmt.Sprintf("OrderedIndex_%s_%sKey", x.messagerName(), index.Name()) } } diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go index 3792edbf..84d6c370 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go @@ -2,16 +2,14 @@ package orderedmap import ( "fmt" + "strings" - "github.com/iancoleman/strcase" "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" "github.com/tableauio/loader/internal/options" "google.golang.org/protobuf/compiler/protogen" "google.golang.org/protobuf/reflect/protoreflect" ) -var orderedMapTypeDefMap map[string]bool = make(map[string]bool) - type Generator struct { gen *protogen.Plugin g *protogen.GeneratedFile @@ -34,12 +32,20 @@ func (x *Generator) messagerName() string { return string(x.message.Desc.Name()) } +func (x *Generator) orderedMapPrefix(mapFd protoreflect.FieldDescriptor) string { + if mapFd.MapValue().Kind() == protoreflect.MessageKind { + localMsgProtoName := strings.TrimPrefix(string(mapFd.MapValue().Message().FullName()), string(x.message.Desc.FullName())+".") + return strings.ReplaceAll(localMsgProtoName, ".", "_") + } + return mapFd.MapValue().Kind().String() +} + func (x *Generator) mapType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("%s_OrderedMap", strcase.ToCamel(string(mapFd.FullName()))) + return fmt.Sprintf("OrderedMap_%s_%sMap", x.messagerName(), x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("%s_OrderedMapValue", strcase.ToCamel(string(mapFd.FullName()))) + return fmt.Sprintf("OrderedMap_%s_%sValue", x.messagerName(), x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { @@ -75,18 +81,14 @@ func (x *Generator) genOrderedMapTypeDef(md protoreflect.MessageDescriptor, dept } orderedMap := x.mapType(fd) orderedMapValue := x.mapValueType(fd) - _, ok := orderedMapTypeDefMap[orderedMap] - if !ok { - orderedMapTypeDefMap[orderedMap] = true - nextMapFD := getNextLevelMapFD(fd.MapValue()) - if nextMapFD != nil { - currValueType := helper.FindMessageGoIdent(x.gen, fd.MapValue().Message()) - nextOrderedMap := x.mapType(nextMapFD) - x.g.P("type ", orderedMapValue, "= ", helper.PairPackage.Ident("Pair"), "[*", nextOrderedMap, ", *", currValueType, "];") - } - x.g.P("type ", orderedMap, "= ", helper.TreeMapPackage.Ident("TreeMap"), "[", keyType, ", ", x.mapValueFieldType(fd), "]") - x.g.P() + nextMapFD := getNextLevelMapFD(fd.MapValue()) + if nextMapFD != nil { + currValueType := helper.FindMessageGoIdent(x.gen, fd.MapValue().Message()) + nextOrderedMap := x.mapType(nextMapFD) + x.g.P("type ", orderedMapValue, "= ", helper.PairPackage.Ident("Pair"), "[*", nextOrderedMap, ", *", currValueType, "];") } + x.g.P("type ", orderedMap, "= ", helper.TreeMapPackage.Ident("TreeMap"), "[", keyType, ", ", x.mapValueFieldType(fd), "]") + x.g.P() return } } diff --git a/test/cpp-tableau-loader/src/main.cpp b/test/cpp-tableau-loader/src/main.cpp index 5a69857b..d532e0ed 100644 --- a/test/cpp-tableau-loader/src/main.cpp +++ b/test/cpp-tableau-loader/src/main.cpp @@ -185,7 +185,7 @@ int main() { // std::cout << section_conf->DebugString() << std::endl; const auto* chapter_ordered_map = - Hub::Instance().GetOrderedMap( + Hub::Instance().GetOrderedMap( 100001); if (!chapter_ordered_map) { ATOM_ERROR("ActivityConf GetOrderedMap chapter failed!"); @@ -209,7 +209,8 @@ int main() { } const auto* rank_ordered_map = - Hub::Instance().GetOrderedMap(100001, 1, 2); + Hub::Instance().GetOrderedMap(100001, 1, + 2); if (!rank_ordered_map) { ATOM_ERROR("ActivityConf GetOrderedMap rank failed!"); return 1; diff --git a/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.cc index e7e530e9..3a60358a 100644 --- a/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.cc @@ -24,7 +24,7 @@ bool HeroConf::ProcessAfterLoad() { // OrderedMap init. ordered_map_.clear(); for (auto&& item1 : data_.hero_map()) { - ordered_map_[item1.first] = Hero_OrderedMapValue(Hero_Attr_OrderedMap(), &item1.second); + ordered_map_[item1.first] = OrderedMap_HeroValue(OrderedMap_Hero_AttrMap(), &item1.second); auto&& ordered_map1 = ordered_map_[item1.first].first; for (auto&& item2 : item1.second.attr_map()) { ordered_map1[item2.first] = &item2.second; @@ -53,11 +53,11 @@ const protoconf::HeroConf::Hero::Attr* HeroConf::Get(const std::string& name, co return &iter->second; } -const HeroConf::Hero_OrderedMap* HeroConf::GetOrderedMap() const { +const HeroConf::OrderedMap_HeroMap* HeroConf::GetOrderedMap() const { return &ordered_map_; } -const HeroConf::Hero_Attr_OrderedMap* HeroConf::GetOrderedMap(const std::string& name) const { +const HeroConf::OrderedMap_Hero_AttrMap* HeroConf::GetOrderedMap(const std::string& name) const { const auto* conf = GetOrderedMap(); if (conf == nullptr) { return nullptr; diff --git a/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.h index 4e5a06d8..8c3204d4 100644 --- a/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/hero_conf.pc.h @@ -33,15 +33,15 @@ class HeroConf : public Messager { // OrderedMap accessers. public: - using Hero_Attr_OrderedMap = std::map; - const Hero_Attr_OrderedMap* GetOrderedMap(const std::string& name) const; + using OrderedMap_Hero_AttrMap = std::map; + const OrderedMap_Hero_AttrMap* GetOrderedMap(const std::string& name) const; - using Hero_OrderedMapValue = std::pair; - using Hero_OrderedMap = std::map; - const Hero_OrderedMap* GetOrderedMap() const; + using OrderedMap_HeroValue = std::pair; + using OrderedMap_HeroMap = std::map; + const OrderedMap_HeroMap* GetOrderedMap() const; private: - Hero_OrderedMap ordered_map_; + OrderedMap_HeroMap ordered_map_; }; class HeroBaseConf : public Messager { diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc index 8abdc097..15fee8e3 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc @@ -146,12 +146,12 @@ const protoconf::ItemConf::Item* ItemConf::Get(uint32_t id) const { return &iter->second; } -const ItemConf::Item_OrderedMap* ItemConf::GetOrderedMap() const { +const ItemConf::OrderedMap_ItemMap* ItemConf::GetOrderedMap() const { return &ordered_map_; } // Index: Type -const ItemConf::Index_ItemMap& ItemConf::FindItem() const { return index_item_map_ ;} +const ItemConf::Index_ItemMap& ItemConf::FindItemMap() const { return index_item_map_ ;} const ItemConf::Index_ItemVector* ItemConf::FindItem(protoconf::FruitType type) const { auto iter = index_item_map_.find(type); @@ -170,7 +170,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItem(protoconf::FruitType ty } // Index: Param@ItemInfo -const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfo() const { return index_item_info_map_ ;} +const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfoMap() const { return index_item_info_map_ ;} const ItemConf::Index_ItemInfoVector* ItemConf::FindItemInfo(int32_t param) const { auto iter = index_item_info_map_.find(param); @@ -189,7 +189,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemInfo(int32_t param) cons } // Index: Default@ItemDefaultInfo -const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfo() const { return index_item_default_info_map_ ;} +const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfoMap() const { return index_item_default_info_map_ ;} const ItemConf::Index_ItemDefaultInfoVector* ItemConf::FindItemDefaultInfo(const std::string& default_) const { auto iter = index_item_default_info_map_.find(default_); @@ -208,7 +208,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemDefaultInfo(const std::s } // Index: ExtType@ItemExtInfo -const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfo() const { return index_item_ext_info_map_ ;} +const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfoMap() const { return index_item_ext_info_map_ ;} const ItemConf::Index_ItemExtInfoVector* ItemConf::FindItemExtInfo(protoconf::FruitType ext_type) const { auto iter = index_item_ext_info_map_.find(ext_type); @@ -227,7 +227,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemExtInfo(protoconf::Fruit } // Index: (ID,Name)@AwardItem -const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItem() const { return index_award_item_map_ ;} +const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItemMap() const { return index_award_item_map_ ;} const ItemConf::Index_AwardItemVector* ItemConf::FindAwardItem(uint32_t id, const std::string& name) const { auto iter = index_award_item_map_.find({id, name}); @@ -246,7 +246,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstAwardItem(uint32_t id, const } // Index: (ID,Type,Param,ExtType)@SpecialItem -const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItem() const { return index_special_item_map_ ;} +const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItemMap() const { return index_special_item_map_ ;} const ItemConf::Index_SpecialItemVector* ItemConf::FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const { auto iter = index_special_item_map_.find({id, type, param, ext_type}); @@ -265,7 +265,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstSpecialItem(uint32_t id, pro } // Index: PathDir@ItemPathDir -const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDir() const { return index_item_path_dir_map_ ;} +const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDirMap() const { return index_item_path_dir_map_ ;} const ItemConf::Index_ItemPathDirVector* ItemConf::FindItemPathDir(const std::string& dir) const { auto iter = index_item_path_dir_map_.find(dir); @@ -284,7 +284,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathDir(const std::strin } // Index: PathName@ItemPathName -const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathName() const { return index_item_path_name_map_ ;} +const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathNameMap() const { return index_item_path_name_map_ ;} const ItemConf::Index_ItemPathNameVector* ItemConf::FindItemPathName(const std::string& name) const { auto iter = index_item_path_name_map_.find(name); @@ -303,7 +303,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathName(const std::stri } // Index: PathFriendID@ItemPathFriendID -const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendID() const { return index_item_path_friend_id_map_ ;} +const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendIDMap() const { return index_item_path_friend_id_map_ ;} const ItemConf::Index_ItemPathFriendIDVector* ItemConf::FindItemPathFriendID(uint32_t id) const { auto iter = index_item_path_friend_id_map_.find(id); @@ -322,7 +322,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathFriendID(uint32_t id } // Index: UseEffectType@UseEffectType -const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectType() const { return index_use_effect_type_map_ ;} +const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectTypeMap() const { return index_use_effect_type_map_ ;} const ItemConf::Index_UseEffectTypeVector* ItemConf::FindUseEffectType(protoconf::UseEffect::Type type) const { auto iter = index_use_effect_type_map_.find(type); @@ -341,7 +341,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstUseEffectType(protoconf::Use } // OrderedIndex: ExtType@ExtType -const ItemConf::OrderedIndex_ExtTypeMap& ItemConf::FindExtType() const { return ordered_index_ext_type_map_ ;} +const ItemConf::OrderedIndex_ExtTypeMap& ItemConf::FindExtTypeMap() const { return ordered_index_ext_type_map_ ;} const ItemConf::OrderedIndex_ExtTypeVector* ItemConf::FindExtType(protoconf::FruitType ext_type) const { auto iter = ordered_index_ext_type_map_.find(ext_type); @@ -360,7 +360,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstExtType(protoconf::FruitType } // OrderedIndex: (Param,ExtType)@ParamExtType -const ItemConf::OrderedIndex_ParamExtTypeMap& ItemConf::FindParamExtType() const { return ordered_index_param_ext_type_map_ ;} +const ItemConf::OrderedIndex_ParamExtTypeMap& ItemConf::FindParamExtTypeMap() const { return ordered_index_param_ext_type_map_ ;} const ItemConf::OrderedIndex_ParamExtTypeVector* ItemConf::FindParamExtType(int32_t param, protoconf::FruitType ext_type) const { auto iter = ordered_index_param_ext_type_map_.find({param, ext_type}); diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h index 45fff5fa..a468f7c3 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h @@ -32,11 +32,11 @@ class ItemConf : public Messager { // OrderedMap accessers. public: - using Item_OrderedMap = std::map; - const Item_OrderedMap* GetOrderedMap() const; + using OrderedMap_ItemMap = std::map; + const OrderedMap_ItemMap* GetOrderedMap() const; private: - Item_OrderedMap ordered_map_; + OrderedMap_ItemMap ordered_map_; // Index accessers. // Index: Type @@ -45,7 +45,7 @@ class ItemConf : public Messager { using Index_ItemMap = std::unordered_map; // Finds the index (Type) to value (Index_ItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemMap& FindItem() const; + const Index_ItemMap& FindItemMap() const; // Finds a vector of all values of the given key(s). const Index_ItemVector* FindItem(protoconf::FruitType type) const; // Finds the first value of the given key(s). @@ -60,7 +60,7 @@ class ItemConf : public Messager { using Index_ItemInfoMap = std::unordered_map; // Finds the index (Param@ItemInfo) to value (Index_ItemInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemInfoMap& FindItemInfo() const; + const Index_ItemInfoMap& FindItemInfoMap() const; // Finds a vector of all values of the given key(s). const Index_ItemInfoVector* FindItemInfo(int32_t param) const; // Finds the first value of the given key(s). @@ -75,7 +75,7 @@ class ItemConf : public Messager { using Index_ItemDefaultInfoMap = std::unordered_map; // Finds the index (Default@ItemDefaultInfo) to value (Index_ItemDefaultInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemDefaultInfoMap& FindItemDefaultInfo() const; + const Index_ItemDefaultInfoMap& FindItemDefaultInfoMap() const; // Finds a vector of all values of the given key(s). const Index_ItemDefaultInfoVector* FindItemDefaultInfo(const std::string& default_) const; // Finds the first value of the given key(s). @@ -90,7 +90,7 @@ class ItemConf : public Messager { using Index_ItemExtInfoMap = std::unordered_map; // Finds the index (ExtType@ItemExtInfo) to value (Index_ItemExtInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemExtInfoMap& FindItemExtInfo() const; + const Index_ItemExtInfoMap& FindItemExtInfoMap() const; // Finds a vector of all values of the given key(s). const Index_ItemExtInfoVector* FindItemExtInfo(protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -121,7 +121,7 @@ class ItemConf : public Messager { using Index_AwardItemMap = std::unordered_map; // Finds the index ((ID,Name)@AwardItem) to value (Index_AwardItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardItemMap& FindAwardItem() const; + const Index_AwardItemMap& FindAwardItemMap() const; // Finds a vector of all values of the given key(s). const Index_AwardItemVector* FindAwardItem(uint32_t id, const std::string& name) const; // Finds the first value of the given key(s). @@ -154,7 +154,7 @@ class ItemConf : public Messager { using Index_SpecialItemMap = std::unordered_map; // Finds the index ((ID,Type,Param,ExtType)@SpecialItem) to value (Index_SpecialItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_SpecialItemMap& FindSpecialItem() const; + const Index_SpecialItemMap& FindSpecialItemMap() const; // Finds a vector of all values of the given key(s). const Index_SpecialItemVector* FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -169,7 +169,7 @@ class ItemConf : public Messager { using Index_ItemPathDirMap = std::unordered_map; // Finds the index (PathDir@ItemPathDir) to value (Index_ItemPathDirVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathDirMap& FindItemPathDir() const; + const Index_ItemPathDirMap& FindItemPathDirMap() const; // Finds a vector of all values of the given key(s). const Index_ItemPathDirVector* FindItemPathDir(const std::string& dir) const; // Finds the first value of the given key(s). @@ -184,7 +184,7 @@ class ItemConf : public Messager { using Index_ItemPathNameMap = std::unordered_map; // Finds the index (PathName@ItemPathName) to value (Index_ItemPathNameVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathNameMap& FindItemPathName() const; + const Index_ItemPathNameMap& FindItemPathNameMap() const; // Finds a vector of all values of the given key(s). const Index_ItemPathNameVector* FindItemPathName(const std::string& name) const; // Finds the first value of the given key(s). @@ -199,7 +199,7 @@ class ItemConf : public Messager { using Index_ItemPathFriendIDMap = std::unordered_map; // Finds the index (PathFriendID@ItemPathFriendID) to value (Index_ItemPathFriendIDVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathFriendIDMap& FindItemPathFriendID() const; + const Index_ItemPathFriendIDMap& FindItemPathFriendIDMap() const; // Finds a vector of all values of the given key(s). const Index_ItemPathFriendIDVector* FindItemPathFriendID(uint32_t id) const; // Finds the first value of the given key(s). @@ -214,7 +214,7 @@ class ItemConf : public Messager { using Index_UseEffectTypeMap = std::unordered_map; // Finds the index (UseEffectType@UseEffectType) to value (Index_UseEffectTypeVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_UseEffectTypeMap& FindUseEffectType() const; + const Index_UseEffectTypeMap& FindUseEffectTypeMap() const; // Finds a vector of all values of the given key(s). const Index_UseEffectTypeVector* FindUseEffectType(protoconf::UseEffect::Type type) const; // Finds the first value of the given key(s). @@ -230,7 +230,7 @@ class ItemConf : public Messager { using OrderedIndex_ExtTypeMap = std::map; // Finds the ordered index (ExtType@ExtType) to value (OrderedIndex_ExtTypeVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ExtTypeMap& FindExtType() const; + const OrderedIndex_ExtTypeMap& FindExtTypeMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ExtTypeVector* FindExtType(protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -259,7 +259,7 @@ class ItemConf : public Messager { using OrderedIndex_ParamExtTypeMap = std::map; // Finds the ordered index ((Param,ExtType)@ParamExtType) to value (OrderedIndex_ParamExtTypeVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ParamExtTypeMap& FindParamExtType() const; + const OrderedIndex_ParamExtTypeMap& FindParamExtTypeMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ParamExtTypeVector* FindParamExtType(int32_t param, protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc index 9eb3c4c8..2bf19eee 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc @@ -24,13 +24,13 @@ bool ActivityConf::ProcessAfterLoad() { // OrderedMap init. ordered_map_.clear(); for (auto&& item1 : data_.activity_map()) { - ordered_map_[item1.first] = Activity_OrderedMapValue(Activity_Chapter_OrderedMap(), &item1.second); + ordered_map_[item1.first] = OrderedMap_ActivityValue(OrderedMap_Activity_ChapterMap(), &item1.second); auto&& ordered_map1 = ordered_map_[item1.first].first; for (auto&& item2 : item1.second.chapter_map()) { - ordered_map1[item2.first] = Activity_Chapter_OrderedMapValue(protoconf_Section_OrderedMap(), &item2.second); + ordered_map1[item2.first] = OrderedMap_Activity_ChapterValue(OrderedMap_protoconf_SectionMap(), &item2.second); auto&& ordered_map2 = ordered_map1[item2.first].first; for (auto&& item3 : item2.second.section_map()) { - ordered_map2[item3.first] = protoconf_Section_OrderedMapValue(int32_OrderedMap(), &item3.second); + ordered_map2[item3.first] = OrderedMap_protoconf_SectionValue(OrderedMap_int32Map(), &item3.second); auto&& ordered_map3 = ordered_map2[item3.first].first; for (auto&& item4 : item3.second.section_rank_map()) { ordered_map3[item4.first] = item4.second; @@ -121,11 +121,11 @@ const int32_t* ActivityConf::Get(uint64_t activity_id, uint32_t chapter_id, uint return &iter->second; } -const ActivityConf::Activity_OrderedMap* ActivityConf::GetOrderedMap() const { +const ActivityConf::OrderedMap_ActivityMap* ActivityConf::GetOrderedMap() const { return &ordered_map_; } -const ActivityConf::Activity_Chapter_OrderedMap* ActivityConf::GetOrderedMap(uint64_t activity_id) const { +const ActivityConf::OrderedMap_Activity_ChapterMap* ActivityConf::GetOrderedMap(uint64_t activity_id) const { const auto* conf = GetOrderedMap(); if (conf == nullptr) { return nullptr; @@ -137,7 +137,7 @@ const ActivityConf::Activity_Chapter_OrderedMap* ActivityConf::GetOrderedMap(uin return &iter->second.first; } -const ActivityConf::protoconf_Section_OrderedMap* ActivityConf::GetOrderedMap(uint64_t activity_id, uint32_t chapter_id) const { +const ActivityConf::OrderedMap_protoconf_SectionMap* ActivityConf::GetOrderedMap(uint64_t activity_id, uint32_t chapter_id) const { const auto* conf = GetOrderedMap(activity_id); if (conf == nullptr) { return nullptr; @@ -149,7 +149,7 @@ const ActivityConf::protoconf_Section_OrderedMap* ActivityConf::GetOrderedMap(ui return &iter->second.first; } -const ActivityConf::int32_OrderedMap* ActivityConf::GetOrderedMap(uint64_t activity_id, uint32_t chapter_id, uint32_t section_id) const { +const ActivityConf::OrderedMap_int32Map* ActivityConf::GetOrderedMap(uint64_t activity_id, uint32_t chapter_id, uint32_t section_id) const { const auto* conf = GetOrderedMap(activity_id, chapter_id); if (conf == nullptr) { return nullptr; @@ -162,7 +162,7 @@ const ActivityConf::int32_OrderedMap* ActivityConf::GetOrderedMap(uint64_t activ } // Index: ActivityName -const ActivityConf::Index_ActivityMap& ActivityConf::FindActivity() const { return index_activity_map_ ;} +const ActivityConf::Index_ActivityMap& ActivityConf::FindActivityMap() const { return index_activity_map_ ;} const ActivityConf::Index_ActivityVector* ActivityConf::FindActivity(const std::string& activity_name) const { auto iter = index_activity_map_.find(activity_name); @@ -181,7 +181,7 @@ const protoconf::ActivityConf::Activity* ActivityConf::FindFirstActivity(const s } // Index: ChapterID -const ActivityConf::Index_ChapterMap& ActivityConf::FindChapter() const { return index_chapter_map_ ;} +const ActivityConf::Index_ChapterMap& ActivityConf::FindChapterMap() const { return index_chapter_map_ ;} const ActivityConf::Index_ChapterVector* ActivityConf::FindChapter(uint32_t chapter_id) const { auto iter = index_chapter_map_.find(chapter_id); @@ -200,7 +200,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstChapter } // Index: ChapterName@NamedChapter -const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapter() const { return index_named_chapter_map_ ;} +const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapterMap() const { return index_named_chapter_map_ ;} const ActivityConf::Index_NamedChapterVector* ActivityConf::FindNamedChapter(const std::string& chapter_name) const { auto iter = index_named_chapter_map_.find(chapter_name); @@ -219,7 +219,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstNamedCh } // Index: SectionItemID@Award -const ActivityConf::Index_AwardMap& ActivityConf::FindAward() const { return index_award_map_ ;} +const ActivityConf::Index_AwardMap& ActivityConf::FindAwardMap() const { return index_award_map_ ;} const ActivityConf::Index_AwardVector* ActivityConf::FindAward(uint32_t id) const { auto iter = index_award_map_.find(id); @@ -367,7 +367,7 @@ const protoconf::TaskConf::Task* TaskConf::Get(int64_t id) const { } // Index: ActivityID -const TaskConf::Index_TaskMap& TaskConf::FindTask() const { return index_task_map_ ;} +const TaskConf::Index_TaskMap& TaskConf::FindTaskMap() const { return index_task_map_ ;} const TaskConf::Index_TaskVector* TaskConf::FindTask(int64_t activity_id) const { auto iter = index_task_map_.find(activity_id); @@ -386,7 +386,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstTask(int64_t activity_id) co } // OrderedIndex: Goal@OrderedTask -const TaskConf::OrderedIndex_OrderedTaskMap& TaskConf::FindOrderedTask() const { return ordered_index_ordered_task_map_ ;} +const TaskConf::OrderedIndex_OrderedTaskMap& TaskConf::FindOrderedTaskMap() const { return ordered_index_ordered_task_map_ ;} const TaskConf::OrderedIndex_OrderedTaskVector* TaskConf::FindOrderedTask(int64_t goal) const { auto iter = ordered_index_ordered_task_map_.find(goal); @@ -405,7 +405,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstOrderedTask(int64_t goal) co } // OrderedIndex: Expiry@TaskExpiry -const TaskConf::OrderedIndex_TaskExpiryMap& TaskConf::FindTaskExpiry() const { return ordered_index_task_expiry_map_ ;} +const TaskConf::OrderedIndex_TaskExpiryMap& TaskConf::FindTaskExpiryMap() const { return ordered_index_task_expiry_map_ ;} const TaskConf::OrderedIndex_TaskExpiryVector* TaskConf::FindTaskExpiry(int64_t expiry) const { auto iter = ordered_index_task_expiry_map_.find(expiry); @@ -424,7 +424,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstTaskExpiry(int64_t expiry) c } // OrderedIndex: Expiry@SortedTaskExpiry -const TaskConf::OrderedIndex_SortedTaskExpiryMap& TaskConf::FindSortedTaskExpiry() const { return ordered_index_sorted_task_expiry_map_ ;} +const TaskConf::OrderedIndex_SortedTaskExpiryMap& TaskConf::FindSortedTaskExpiryMap() const { return ordered_index_sorted_task_expiry_map_ ;} const TaskConf::OrderedIndex_SortedTaskExpiryVector* TaskConf::FindSortedTaskExpiry(int64_t expiry) const { auto iter = ordered_index_sorted_task_expiry_map_.find(expiry); @@ -443,7 +443,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstSortedTaskExpiry(int64_t exp } // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry -const TaskConf::OrderedIndex_ActivityExpiryMap& TaskConf::FindActivityExpiry() const { return ordered_index_activity_expiry_map_ ;} +const TaskConf::OrderedIndex_ActivityExpiryMap& TaskConf::FindActivityExpiryMap() const { return ordered_index_activity_expiry_map_ ;} const TaskConf::OrderedIndex_ActivityExpiryVector* TaskConf::FindActivityExpiry(int64_t expiry, int64_t activity_id) const { auto iter = ordered_index_activity_expiry_map_.find({expiry, activity_id}); diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h index ae635ce0..005de675 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h @@ -35,23 +35,23 @@ class ActivityConf : public Messager { // OrderedMap accessers. public: - using int32_OrderedMap = std::map; - const int32_OrderedMap* GetOrderedMap(uint64_t activity_id, uint32_t chapter_id, uint32_t section_id) const; + using OrderedMap_int32Map = std::map; + const OrderedMap_int32Map* GetOrderedMap(uint64_t activity_id, uint32_t chapter_id, uint32_t section_id) const; - using protoconf_Section_OrderedMapValue = std::pair; - using protoconf_Section_OrderedMap = std::map; - const protoconf_Section_OrderedMap* GetOrderedMap(uint64_t activity_id, uint32_t chapter_id) const; + using OrderedMap_protoconf_SectionValue = std::pair; + using OrderedMap_protoconf_SectionMap = std::map; + const OrderedMap_protoconf_SectionMap* GetOrderedMap(uint64_t activity_id, uint32_t chapter_id) const; - using Activity_Chapter_OrderedMapValue = std::pair; - using Activity_Chapter_OrderedMap = std::map; - const Activity_Chapter_OrderedMap* GetOrderedMap(uint64_t activity_id) const; + using OrderedMap_Activity_ChapterValue = std::pair; + using OrderedMap_Activity_ChapterMap = std::map; + const OrderedMap_Activity_ChapterMap* GetOrderedMap(uint64_t activity_id) const; - using Activity_OrderedMapValue = std::pair; - using Activity_OrderedMap = std::map; - const Activity_OrderedMap* GetOrderedMap() const; + using OrderedMap_ActivityValue = std::pair; + using OrderedMap_ActivityMap = std::map; + const OrderedMap_ActivityMap* GetOrderedMap() const; private: - Activity_OrderedMap ordered_map_; + OrderedMap_ActivityMap ordered_map_; // Index accessers. // Index: ActivityName @@ -60,7 +60,7 @@ class ActivityConf : public Messager { using Index_ActivityMap = std::unordered_map; // Finds the index (ActivityName) to value (Index_ActivityVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ActivityMap& FindActivity() const; + const Index_ActivityMap& FindActivityMap() const; // Finds a vector of all values of the given key(s). const Index_ActivityVector* FindActivity(const std::string& activity_name) const; // Finds the first value of the given key(s). @@ -75,7 +75,7 @@ class ActivityConf : public Messager { using Index_ChapterMap = std::unordered_map; // Finds the index (ChapterID) to value (Index_ChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ChapterMap& FindChapter() const; + const Index_ChapterMap& FindChapterMap() const; // Finds a vector of all values of the given key(s). const Index_ChapterVector* FindChapter(uint32_t chapter_id) const; // Finds the first value of the given key(s). @@ -90,7 +90,7 @@ class ActivityConf : public Messager { using Index_NamedChapterMap = std::unordered_map; // Finds the index (ChapterName@NamedChapter) to value (Index_NamedChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_NamedChapterMap& FindNamedChapter() const; + const Index_NamedChapterMap& FindNamedChapterMap() const; // Finds a vector of all values of the given key(s). const Index_NamedChapterVector* FindNamedChapter(const std::string& chapter_name) const; // Finds the first value of the given key(s). @@ -105,7 +105,7 @@ class ActivityConf : public Messager { using Index_AwardMap = std::unordered_map; // Finds the index (SectionItemID@Award) to value (Index_AwardVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardMap& FindAward() const; + const Index_AwardMap& FindAwardMap() const; // Finds a vector of all values of the given key(s). const Index_AwardVector* FindAward(uint32_t id) const; // Finds the first value of the given key(s). @@ -171,7 +171,7 @@ class TaskConf : public Messager { using Index_TaskMap = std::unordered_map; // Finds the index (ActivityID) to value (Index_TaskVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_TaskMap& FindTask() const; + const Index_TaskMap& FindTaskMap() const; // Finds a vector of all values of the given key(s). const Index_TaskVector* FindTask(int64_t activity_id) const; // Finds the first value of the given key(s). @@ -187,7 +187,7 @@ class TaskConf : public Messager { using OrderedIndex_OrderedTaskMap = std::map; // Finds the ordered index (Goal@OrderedTask) to value (OrderedIndex_OrderedTaskVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_OrderedTaskMap& FindOrderedTask() const; + const OrderedIndex_OrderedTaskMap& FindOrderedTaskMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_OrderedTaskVector* FindOrderedTask(int64_t goal) const; // Finds the first value of the given key(s). @@ -202,7 +202,7 @@ class TaskConf : public Messager { using OrderedIndex_TaskExpiryMap = std::map; // Finds the ordered index (Expiry@TaskExpiry) to value (OrderedIndex_TaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_TaskExpiryMap& FindTaskExpiry() const; + const OrderedIndex_TaskExpiryMap& FindTaskExpiryMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_TaskExpiryVector* FindTaskExpiry(int64_t expiry) const; // Finds the first value of the given key(s). @@ -217,7 +217,7 @@ class TaskConf : public Messager { using OrderedIndex_SortedTaskExpiryMap = std::map; // Finds the ordered index (Expiry@SortedTaskExpiry) to value (OrderedIndex_SortedTaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_SortedTaskExpiryMap& FindSortedTaskExpiry() const; + const OrderedIndex_SortedTaskExpiryMap& FindSortedTaskExpiryMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_SortedTaskExpiryVector* FindSortedTaskExpiry(int64_t expiry) const; // Finds the first value of the given key(s). @@ -246,7 +246,7 @@ class TaskConf : public Messager { using OrderedIndex_ActivityExpiryMap = std::map; // Finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (OrderedIndex_ActivityExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ActivityExpiryMap& FindActivityExpiry() const; + const OrderedIndex_ActivityExpiryMap& FindActivityExpiryMap() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ActivityExpiryVector* FindActivityExpiry(int64_t expiry, int64_t activity_id) const; // Finds the first value of the given key(s). diff --git a/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go b/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go index 4f5918c5..37c94ba3 100644 --- a/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go @@ -21,7 +21,7 @@ import ( // Index types. // Index: Title -type HeroConf_Index_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr +type Index_HeroConf_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr // HeroConf is a wrapper around protobuf message: protoconf.HeroConf. // @@ -33,7 +33,7 @@ type HeroConf_Index_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr type HeroConf struct { UnimplementedMessager data, originalData *protoconf.HeroConf - indexAttrMap HeroConf_Index_AttrMap + indexAttrMap Index_HeroConf_AttrMap } // Name returns the HeroConf's message name. @@ -96,7 +96,7 @@ func (x *HeroConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *HeroConf) processAfterLoad() error { // Index init. - x.indexAttrMap = make(HeroConf_Index_AttrMap) + x.indexAttrMap = make(Index_HeroConf_AttrMap) for _, item1 := range x.data.GetHeroMap() { for _, item2 := range item1.GetAttrMap() { { @@ -139,7 +139,7 @@ func (x *HeroConf) Get2(name string, title string) (*protoconf.HeroConf_Hero_Att // FindAttrMap finds the index (Title) to value (protoconf.HeroConf_Hero_Attr) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *HeroConf) FindAttrMap() HeroConf_Index_AttrMap { +func (x *HeroConf) FindAttrMap() Index_HeroConf_AttrMap { return x.indexAttrMap } @@ -159,10 +159,10 @@ func (x *HeroConf) FindFirstAttr(title string) *protoconf.HeroConf_Hero_Attr { } // OrderedMap types. -type BaseHeroItemMap_OrderedMap = treemap.TreeMap[string, *base.Item] +type OrderedMap_HeroBaseConf_base_ItemMap = treemap.TreeMap[string, *base.Item] -type ProtoconfHeroBaseConfHeroMap_OrderedMapValue = pair.Pair[*BaseHeroItemMap_OrderedMap, *base.Hero] -type ProtoconfHeroBaseConfHeroMap_OrderedMap = treemap.TreeMap[string, *ProtoconfHeroBaseConfHeroMap_OrderedMapValue] +type OrderedMap_HeroBaseConf_base_HeroValue = pair.Pair[*OrderedMap_HeroBaseConf_base_ItemMap, *base.Hero] +type OrderedMap_HeroBaseConf_base_HeroMap = treemap.TreeMap[string, *OrderedMap_HeroBaseConf_base_HeroValue] // HeroBaseConf is a wrapper around protobuf message: protoconf.HeroBaseConf. // @@ -174,7 +174,7 @@ type ProtoconfHeroBaseConfHeroMap_OrderedMap = treemap.TreeMap[string, *Protocon type HeroBaseConf struct { UnimplementedMessager data, originalData *protoconf.HeroBaseConf - orderedMap *ProtoconfHeroBaseConfHeroMap_OrderedMap + orderedMap *OrderedMap_HeroBaseConf_base_HeroMap } // Name returns the HeroBaseConf's message name. @@ -237,10 +237,10 @@ func (x *HeroBaseConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *HeroBaseConf) processAfterLoad() error { // OrderedMap init. - x.orderedMap = treemap.New[string, *ProtoconfHeroBaseConfHeroMap_OrderedMapValue]() + x.orderedMap = treemap.New[string, *OrderedMap_HeroBaseConf_base_HeroValue]() for k1, v1 := range x.Data().GetHeroMap() { map1 := x.orderedMap - k1v := &ProtoconfHeroBaseConfHeroMap_OrderedMapValue{ + k1v := &OrderedMap_HeroBaseConf_base_HeroValue{ First: treemap.New[string, *base.Item](), Second: v1, } @@ -280,13 +280,13 @@ func (x *HeroBaseConf) Get2(name string, id string) (*base.Item, error) { } // GetOrderedMap returns the 1-level ordered map. -func (x *HeroBaseConf) GetOrderedMap() *ProtoconfHeroBaseConfHeroMap_OrderedMap { +func (x *HeroBaseConf) GetOrderedMap() *OrderedMap_HeroBaseConf_base_HeroMap { return x.orderedMap } // GetOrderedMap1 finds value in the 1-level ordered map. It will return // NotFound error if the key is not found. -func (x *HeroBaseConf) GetOrderedMap1(name string) (*BaseHeroItemMap_OrderedMap, error) { +func (x *HeroBaseConf) GetOrderedMap1(name string) (*OrderedMap_HeroBaseConf_base_ItemMap, error) { conf := x.orderedMap if val, ok := conf.Get(name); !ok { return nil, fmt.Errorf("name(%v) %w", name, ErrNotFound) diff --git a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go index 991779b8..cf139cc6 100644 --- a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go @@ -19,67 +19,67 @@ import ( ) // OrderedMap types. -type ProtoconfItemConfItemMap_OrderedMap = treemap.TreeMap[uint32, *protoconf.ItemConf_Item] +type OrderedMap_ItemConf_ItemMap = treemap.TreeMap[uint32, *protoconf.ItemConf_Item] // Index types. // Index: Type -type ItemConf_Index_ItemMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item // Index: Param@ItemInfo -type ItemConf_Index_ItemInfoMap = map[int32][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemInfoMap = map[int32][]*protoconf.ItemConf_Item // Index: Default@ItemDefaultInfo -type ItemConf_Index_ItemDefaultInfoMap = map[string][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemDefaultInfoMap = map[string][]*protoconf.ItemConf_Item // Index: ExtType@ItemExtInfo -type ItemConf_Index_ItemExtInfoMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemExtInfoMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item // Index: (ID,Name)@AwardItem -type ItemConf_Index_AwardItemKey struct { +type Index_ItemConf_AwardItemKey struct { Id uint32 Name string } -type ItemConf_Index_AwardItemMap = map[ItemConf_Index_AwardItemKey][]*protoconf.ItemConf_Item +type Index_ItemConf_AwardItemMap = map[Index_ItemConf_AwardItemKey][]*protoconf.ItemConf_Item // Index: (ID,Type,Param,ExtType)@SpecialItem -type ItemConf_Index_SpecialItemKey struct { +type Index_ItemConf_SpecialItemKey struct { Id uint32 Type protoconf.FruitType Param int32 ExtType protoconf.FruitType } -type ItemConf_Index_SpecialItemMap = map[ItemConf_Index_SpecialItemKey][]*protoconf.ItemConf_Item +type Index_ItemConf_SpecialItemMap = map[Index_ItemConf_SpecialItemKey][]*protoconf.ItemConf_Item // Index: PathDir@ItemPathDir -type ItemConf_Index_ItemPathDirMap = map[string][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemPathDirMap = map[string][]*protoconf.ItemConf_Item // Index: PathName@ItemPathName -type ItemConf_Index_ItemPathNameMap = map[string][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemPathNameMap = map[string][]*protoconf.ItemConf_Item // Index: PathFriendID@ItemPathFriendID -type ItemConf_Index_ItemPathFriendIDMap = map[uint32][]*protoconf.ItemConf_Item +type Index_ItemConf_ItemPathFriendIDMap = map[uint32][]*protoconf.ItemConf_Item // Index: UseEffectType@UseEffectType -type ItemConf_Index_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf.ItemConf_Item +type Index_ItemConf_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf.ItemConf_Item // OrderedIndex types. // OrderedIndex: ExtType@ExtType -type ItemConf_OrderedIndex_ExtTypeMap = treemap.TreeMap[protoconf.FruitType, []*protoconf.ItemConf_Item] +type OrderedIndex_ItemConf_ExtTypeMap = treemap.TreeMap[protoconf.FruitType, []*protoconf.ItemConf_Item] // OrderedIndex: (Param,ExtType)@ParamExtType -type ItemConf_OrderedIndex_ParamExtTypeKey struct { +type OrderedIndex_ItemConf_ParamExtTypeKey struct { Param int32 ExtType protoconf.FruitType } -func (x ItemConf_OrderedIndex_ParamExtTypeKey) Less(other ItemConf_OrderedIndex_ParamExtTypeKey) bool { +func (x OrderedIndex_ItemConf_ParamExtTypeKey) Less(other OrderedIndex_ItemConf_ParamExtTypeKey) bool { if x.Param != other.Param { return x.Param < other.Param } return x.ExtType < other.ExtType } -type ItemConf_OrderedIndex_ParamExtTypeMap = treemap.TreeMap[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item] +type OrderedIndex_ItemConf_ParamExtTypeMap = treemap.TreeMap[OrderedIndex_ItemConf_ParamExtTypeKey, []*protoconf.ItemConf_Item] // ItemConf is a wrapper around protobuf message: protoconf.ItemConf. // @@ -91,19 +91,19 @@ type ItemConf_OrderedIndex_ParamExtTypeMap = treemap.TreeMap[ItemConf_OrderedInd type ItemConf struct { UnimplementedMessager data, originalData *protoconf.ItemConf - orderedMap *ProtoconfItemConfItemMap_OrderedMap - indexItemMap ItemConf_Index_ItemMap - indexItemInfoMap ItemConf_Index_ItemInfoMap - indexItemDefaultInfoMap ItemConf_Index_ItemDefaultInfoMap - indexItemExtInfoMap ItemConf_Index_ItemExtInfoMap - indexAwardItemMap ItemConf_Index_AwardItemMap - indexSpecialItemMap ItemConf_Index_SpecialItemMap - indexItemPathDirMap ItemConf_Index_ItemPathDirMap - indexItemPathNameMap ItemConf_Index_ItemPathNameMap - indexItemPathFriendIdMap ItemConf_Index_ItemPathFriendIDMap - indexUseEffectTypeMap ItemConf_Index_UseEffectTypeMap - orderedIndexExtTypeMap *ItemConf_OrderedIndex_ExtTypeMap - orderedIndexParamExtTypeMap *ItemConf_OrderedIndex_ParamExtTypeMap + orderedMap *OrderedMap_ItemConf_ItemMap + indexItemMap Index_ItemConf_ItemMap + indexItemInfoMap Index_ItemConf_ItemInfoMap + indexItemDefaultInfoMap Index_ItemConf_ItemDefaultInfoMap + indexItemExtInfoMap Index_ItemConf_ItemExtInfoMap + indexAwardItemMap Index_ItemConf_AwardItemMap + indexSpecialItemMap Index_ItemConf_SpecialItemMap + indexItemPathDirMap Index_ItemConf_ItemPathDirMap + indexItemPathNameMap Index_ItemConf_ItemPathNameMap + indexItemPathFriendIdMap Index_ItemConf_ItemPathFriendIDMap + indexUseEffectTypeMap Index_ItemConf_UseEffectTypeMap + orderedIndexExtTypeMap *OrderedIndex_ItemConf_ExtTypeMap + orderedIndexParamExtTypeMap *OrderedIndex_ItemConf_ParamExtTypeMap } // Name returns the ItemConf's message name. @@ -172,16 +172,16 @@ func (x *ItemConf) processAfterLoad() error { map1.Put(k1, v1) } // Index init. - x.indexItemMap = make(ItemConf_Index_ItemMap) - x.indexItemInfoMap = make(ItemConf_Index_ItemInfoMap) - x.indexItemDefaultInfoMap = make(ItemConf_Index_ItemDefaultInfoMap) - x.indexItemExtInfoMap = make(ItemConf_Index_ItemExtInfoMap) - x.indexAwardItemMap = make(ItemConf_Index_AwardItemMap) - x.indexSpecialItemMap = make(ItemConf_Index_SpecialItemMap) - x.indexItemPathDirMap = make(ItemConf_Index_ItemPathDirMap) - x.indexItemPathNameMap = make(ItemConf_Index_ItemPathNameMap) - x.indexItemPathFriendIdMap = make(ItemConf_Index_ItemPathFriendIDMap) - x.indexUseEffectTypeMap = make(ItemConf_Index_UseEffectTypeMap) + x.indexItemMap = make(Index_ItemConf_ItemMap) + x.indexItemInfoMap = make(Index_ItemConf_ItemInfoMap) + x.indexItemDefaultInfoMap = make(Index_ItemConf_ItemDefaultInfoMap) + x.indexItemExtInfoMap = make(Index_ItemConf_ItemExtInfoMap) + x.indexAwardItemMap = make(Index_ItemConf_AwardItemMap) + x.indexSpecialItemMap = make(Index_ItemConf_SpecialItemMap) + x.indexItemPathDirMap = make(Index_ItemConf_ItemPathDirMap) + x.indexItemPathNameMap = make(Index_ItemConf_ItemPathNameMap) + x.indexItemPathFriendIdMap = make(Index_ItemConf_ItemPathFriendIDMap) + x.indexUseEffectTypeMap = make(Index_ItemConf_UseEffectTypeMap) for _, item1 := range x.data.GetItemMap() { { // Index: Type @@ -209,14 +209,14 @@ func (x *ItemConf) processAfterLoad() error { } { // Index: (ID,Name)@AwardItem - key := ItemConf_Index_AwardItemKey{item1.GetId(), item1.GetName()} + key := Index_ItemConf_AwardItemKey{item1.GetId(), item1.GetName()} x.indexAwardItemMap[key] = append(x.indexAwardItemMap[key], item1) } { // Index: (ID,Type,Param,ExtType)@SpecialItem for _, indexItem2 := range item1.GetParamList() { for _, indexItem3 := range item1.GetExtTypeList() { - key := ItemConf_Index_SpecialItemKey{item1.GetId(), item1.GetType(), indexItem2, indexItem3} + key := Index_ItemConf_SpecialItemKey{item1.GetId(), item1.GetType(), indexItem2, indexItem3} x.indexSpecialItemMap[key] = append(x.indexSpecialItemMap[key], item1) } } @@ -261,7 +261,7 @@ func (x *ItemConf) processAfterLoad() error { } // OrderedIndex init. x.orderedIndexExtTypeMap = treemap.New[protoconf.FruitType, []*protoconf.ItemConf_Item]() - x.orderedIndexParamExtTypeMap = treemap.New2[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item]() + x.orderedIndexParamExtTypeMap = treemap.New2[OrderedIndex_ItemConf_ParamExtTypeKey, []*protoconf.ItemConf_Item]() for _, item1 := range x.data.GetItemMap() { { // OrderedIndex: ExtType@ExtType @@ -275,7 +275,7 @@ func (x *ItemConf) processAfterLoad() error { // OrderedIndex: (Param,ExtType)@ParamExtType for _, indexItem0 := range item1.GetParamList() { for _, indexItem1 := range item1.GetExtTypeList() { - key := ItemConf_OrderedIndex_ParamExtTypeKey{indexItem0, indexItem1} + key := OrderedIndex_ItemConf_ParamExtTypeKey{indexItem0, indexItem1} value, _ := x.orderedIndexParamExtTypeMap.Get(key) x.orderedIndexParamExtTypeMap.Put(key, append(value, item1)) } @@ -283,7 +283,7 @@ func (x *ItemConf) processAfterLoad() error { } } // OrderedIndex(sort): (Param,ExtType)@ParamExtType - x.orderedIndexParamExtTypeMap.Range(func(key ItemConf_OrderedIndex_ParamExtTypeKey, item []*protoconf.ItemConf_Item) bool { + x.orderedIndexParamExtTypeMap.Range(func(key OrderedIndex_ItemConf_ParamExtTypeKey, item []*protoconf.ItemConf_Item) bool { sort.Slice(item, func(i, j int) bool { return item[i].GetId() < item[j].GetId() }) @@ -304,7 +304,7 @@ func (x *ItemConf) Get1(id uint32) (*protoconf.ItemConf_Item, error) { } // GetOrderedMap returns the 1-level ordered map. -func (x *ItemConf) GetOrderedMap() *ProtoconfItemConfItemMap_OrderedMap { +func (x *ItemConf) GetOrderedMap() *OrderedMap_ItemConf_ItemMap { return x.orderedMap } @@ -312,7 +312,7 @@ func (x *ItemConf) GetOrderedMap() *ProtoconfItemConfItemMap_OrderedMap { // FindItemMap finds the index (Type) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemMap() ItemConf_Index_ItemMap { +func (x *ItemConf) FindItemMap() Index_ItemConf_ItemMap { return x.indexItemMap } @@ -335,7 +335,7 @@ func (x *ItemConf) FindFirstItem(type_ protoconf.FruitType) *protoconf.ItemConf_ // FindItemInfoMap finds the index (Param@ItemInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemInfoMap() ItemConf_Index_ItemInfoMap { +func (x *ItemConf) FindItemInfoMap() Index_ItemConf_ItemInfoMap { return x.indexItemInfoMap } @@ -358,7 +358,7 @@ func (x *ItemConf) FindFirstItemInfo(param int32) *protoconf.ItemConf_Item { // FindItemDefaultInfoMap finds the index (Default@ItemDefaultInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemDefaultInfoMap() ItemConf_Index_ItemDefaultInfoMap { +func (x *ItemConf) FindItemDefaultInfoMap() Index_ItemConf_ItemDefaultInfoMap { return x.indexItemDefaultInfoMap } @@ -381,7 +381,7 @@ func (x *ItemConf) FindFirstItemDefaultInfo(default_ string) *protoconf.ItemConf // FindItemExtInfoMap finds the index (ExtType@ItemExtInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemExtInfoMap() ItemConf_Index_ItemExtInfoMap { +func (x *ItemConf) FindItemExtInfoMap() Index_ItemConf_ItemExtInfoMap { return x.indexItemExtInfoMap } @@ -404,13 +404,13 @@ func (x *ItemConf) FindFirstItemExtInfo(extType protoconf.FruitType) *protoconf. // FindAwardItemMap finds the index ((ID,Name)@AwardItem) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindAwardItemMap() ItemConf_Index_AwardItemMap { +func (x *ItemConf) FindAwardItemMap() Index_ItemConf_AwardItemMap { return x.indexAwardItemMap } // FindAwardItem finds a slice of all values of the given key. func (x *ItemConf) FindAwardItem(id uint32, name string) []*protoconf.ItemConf_Item { - return x.indexAwardItemMap[ItemConf_Index_AwardItemKey{id, name}] + return x.indexAwardItemMap[Index_ItemConf_AwardItemKey{id, name}] } // FindFirstAwardItem finds the first value of the given key, @@ -427,13 +427,13 @@ func (x *ItemConf) FindFirstAwardItem(id uint32, name string) *protoconf.ItemCon // FindSpecialItemMap finds the index ((ID,Type,Param,ExtType)@SpecialItem) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindSpecialItemMap() ItemConf_Index_SpecialItemMap { +func (x *ItemConf) FindSpecialItemMap() Index_ItemConf_SpecialItemMap { return x.indexSpecialItemMap } // FindSpecialItem finds a slice of all values of the given key. func (x *ItemConf) FindSpecialItem(id uint32, type_ protoconf.FruitType, param int32, extType protoconf.FruitType) []*protoconf.ItemConf_Item { - return x.indexSpecialItemMap[ItemConf_Index_SpecialItemKey{id, type_, param, extType}] + return x.indexSpecialItemMap[Index_ItemConf_SpecialItemKey{id, type_, param, extType}] } // FindFirstSpecialItem finds the first value of the given key, @@ -450,7 +450,7 @@ func (x *ItemConf) FindFirstSpecialItem(id uint32, type_ protoconf.FruitType, pa // FindItemPathDirMap finds the index (PathDir@ItemPathDir) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathDirMap() ItemConf_Index_ItemPathDirMap { +func (x *ItemConf) FindItemPathDirMap() Index_ItemConf_ItemPathDirMap { return x.indexItemPathDirMap } @@ -473,7 +473,7 @@ func (x *ItemConf) FindFirstItemPathDir(dir string) *protoconf.ItemConf_Item { // FindItemPathNameMap finds the index (PathName@ItemPathName) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathNameMap() ItemConf_Index_ItemPathNameMap { +func (x *ItemConf) FindItemPathNameMap() Index_ItemConf_ItemPathNameMap { return x.indexItemPathNameMap } @@ -496,7 +496,7 @@ func (x *ItemConf) FindFirstItemPathName(name string) *protoconf.ItemConf_Item { // FindItemPathFriendIDMap finds the index (PathFriendID@ItemPathFriendID) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathFriendIDMap() ItemConf_Index_ItemPathFriendIDMap { +func (x *ItemConf) FindItemPathFriendIDMap() Index_ItemConf_ItemPathFriendIDMap { return x.indexItemPathFriendIdMap } @@ -519,7 +519,7 @@ func (x *ItemConf) FindFirstItemPathFriendID(id uint32) *protoconf.ItemConf_Item // FindUseEffectTypeMap finds the index (UseEffectType@UseEffectType) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindUseEffectTypeMap() ItemConf_Index_UseEffectTypeMap { +func (x *ItemConf) FindUseEffectTypeMap() Index_ItemConf_UseEffectTypeMap { return x.indexUseEffectTypeMap } @@ -542,7 +542,7 @@ func (x *ItemConf) FindFirstUseEffectType(type_ protoconf.UseEffect_Type) *proto // FindExtTypeMap finds the ordered index (ExtType@ExtType) to value (protoconf.ItemConf_Item) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindExtTypeMap() *ItemConf_OrderedIndex_ExtTypeMap { +func (x *ItemConf) FindExtTypeMap() *OrderedIndex_ItemConf_ExtTypeMap { return x.orderedIndexExtTypeMap } @@ -566,13 +566,13 @@ func (x *ItemConf) FindFirstExtType(extType protoconf.FruitType) *protoconf.Item // FindParamExtTypeMap finds the ordered index ((Param,ExtType)@ParamExtType) to value (protoconf.ItemConf_Item) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindParamExtTypeMap() *ItemConf_OrderedIndex_ParamExtTypeMap { +func (x *ItemConf) FindParamExtTypeMap() *OrderedIndex_ItemConf_ParamExtTypeMap { return x.orderedIndexParamExtTypeMap } // FindParamExtType finds a slice of all values of the given key. func (x *ItemConf) FindParamExtType(param int32, extType protoconf.FruitType) []*protoconf.ItemConf_Item { - val, _ := x.orderedIndexParamExtTypeMap.Get(ItemConf_OrderedIndex_ParamExtTypeKey{param, extType}) + val, _ := x.orderedIndexParamExtTypeMap.Get(OrderedIndex_ItemConf_ParamExtTypeKey{param, extType}) return val } diff --git a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go index c8f02c1a..c2aa15c6 100644 --- a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go @@ -20,29 +20,29 @@ import ( ) // OrderedMap types. -type ProtoconfSectionSectionRankMap_OrderedMap = treemap.TreeMap[uint32, int32] +type OrderedMap_ActivityConf_int32Map = treemap.TreeMap[uint32, int32] -type ProtoconfActivityConfActivityChapterSectionMap_OrderedMapValue = pair.Pair[*ProtoconfSectionSectionRankMap_OrderedMap, *protoconf.Section] -type ProtoconfActivityConfActivityChapterSectionMap_OrderedMap = treemap.TreeMap[uint32, *ProtoconfActivityConfActivityChapterSectionMap_OrderedMapValue] +type OrderedMap_ActivityConf_protoconf_SectionValue = pair.Pair[*OrderedMap_ActivityConf_int32Map, *protoconf.Section] +type OrderedMap_ActivityConf_protoconf_SectionMap = treemap.TreeMap[uint32, *OrderedMap_ActivityConf_protoconf_SectionValue] -type ProtoconfActivityConfActivityChapterMap_OrderedMapValue = pair.Pair[*ProtoconfActivityConfActivityChapterSectionMap_OrderedMap, *protoconf.ActivityConf_Activity_Chapter] -type ProtoconfActivityConfActivityChapterMap_OrderedMap = treemap.TreeMap[uint32, *ProtoconfActivityConfActivityChapterMap_OrderedMapValue] +type OrderedMap_ActivityConf_Activity_ChapterValue = pair.Pair[*OrderedMap_ActivityConf_protoconf_SectionMap, *protoconf.ActivityConf_Activity_Chapter] +type OrderedMap_ActivityConf_Activity_ChapterMap = treemap.TreeMap[uint32, *OrderedMap_ActivityConf_Activity_ChapterValue] -type ProtoconfActivityConfActivityMap_OrderedMapValue = pair.Pair[*ProtoconfActivityConfActivityChapterMap_OrderedMap, *protoconf.ActivityConf_Activity] -type ProtoconfActivityConfActivityMap_OrderedMap = treemap.TreeMap[uint64, *ProtoconfActivityConfActivityMap_OrderedMapValue] +type OrderedMap_ActivityConf_ActivityValue = pair.Pair[*OrderedMap_ActivityConf_Activity_ChapterMap, *protoconf.ActivityConf_Activity] +type OrderedMap_ActivityConf_ActivityMap = treemap.TreeMap[uint64, *OrderedMap_ActivityConf_ActivityValue] // Index types. // Index: ActivityName -type ActivityConf_Index_ActivityMap = map[string][]*protoconf.ActivityConf_Activity +type Index_ActivityConf_ActivityMap = map[string][]*protoconf.ActivityConf_Activity // Index: ChapterID -type ActivityConf_Index_ChapterMap = map[uint32][]*protoconf.ActivityConf_Activity_Chapter +type Index_ActivityConf_ChapterMap = map[uint32][]*protoconf.ActivityConf_Activity_Chapter // Index: ChapterName@NamedChapter -type ActivityConf_Index_NamedChapterMap = map[string][]*protoconf.ActivityConf_Activity_Chapter +type Index_ActivityConf_NamedChapterMap = map[string][]*protoconf.ActivityConf_Activity_Chapter // Index: SectionItemID@Award -type ActivityConf_Index_AwardMap = map[uint32][]*protoconf.Section_SectionItem +type Index_ActivityConf_AwardMap = map[uint32][]*protoconf.Section_SectionItem // ActivityConf is a wrapper around protobuf message: protoconf.ActivityConf. // @@ -54,11 +54,11 @@ type ActivityConf_Index_AwardMap = map[uint32][]*protoconf.Section_SectionItem type ActivityConf struct { UnimplementedMessager data, originalData *protoconf.ActivityConf - orderedMap *ProtoconfActivityConfActivityMap_OrderedMap - indexActivityMap ActivityConf_Index_ActivityMap - indexChapterMap ActivityConf_Index_ChapterMap - indexNamedChapterMap ActivityConf_Index_NamedChapterMap - indexAwardMap ActivityConf_Index_AwardMap + orderedMap *OrderedMap_ActivityConf_ActivityMap + indexActivityMap Index_ActivityConf_ActivityMap + indexChapterMap Index_ActivityConf_ChapterMap + indexNamedChapterMap Index_ActivityConf_NamedChapterMap + indexAwardMap Index_ActivityConf_AwardMap } // Name returns the ActivityConf's message name. @@ -121,24 +121,24 @@ func (x *ActivityConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *ActivityConf) processAfterLoad() error { // OrderedMap init. - x.orderedMap = treemap.New[uint64, *ProtoconfActivityConfActivityMap_OrderedMapValue]() + x.orderedMap = treemap.New[uint64, *OrderedMap_ActivityConf_ActivityValue]() for k1, v1 := range x.Data().GetActivityMap() { map1 := x.orderedMap - k1v := &ProtoconfActivityConfActivityMap_OrderedMapValue{ - First: treemap.New[uint32, *ProtoconfActivityConfActivityChapterMap_OrderedMapValue](), + k1v := &OrderedMap_ActivityConf_ActivityValue{ + First: treemap.New[uint32, *OrderedMap_ActivityConf_Activity_ChapterValue](), Second: v1, } map1.Put(k1, k1v) for k2, v2 := range v1.GetChapterMap() { map2 := k1v.First - k2v := &ProtoconfActivityConfActivityChapterMap_OrderedMapValue{ - First: treemap.New[uint32, *ProtoconfActivityConfActivityChapterSectionMap_OrderedMapValue](), + k2v := &OrderedMap_ActivityConf_Activity_ChapterValue{ + First: treemap.New[uint32, *OrderedMap_ActivityConf_protoconf_SectionValue](), Second: v2, } map2.Put(k2, k2v) for k3, v3 := range v2.GetSectionMap() { map3 := k2v.First - k3v := &ProtoconfActivityConfActivityChapterSectionMap_OrderedMapValue{ + k3v := &OrderedMap_ActivityConf_protoconf_SectionValue{ First: treemap.New[uint32, int32](), Second: v3, } @@ -151,10 +151,10 @@ func (x *ActivityConf) processAfterLoad() error { } } // Index init. - x.indexActivityMap = make(ActivityConf_Index_ActivityMap) - x.indexChapterMap = make(ActivityConf_Index_ChapterMap) - x.indexNamedChapterMap = make(ActivityConf_Index_NamedChapterMap) - x.indexAwardMap = make(ActivityConf_Index_AwardMap) + x.indexActivityMap = make(Index_ActivityConf_ActivityMap) + x.indexChapterMap = make(Index_ActivityConf_ChapterMap) + x.indexNamedChapterMap = make(Index_ActivityConf_NamedChapterMap) + x.indexAwardMap = make(Index_ActivityConf_AwardMap) for _, item1 := range x.data.GetActivityMap() { { // Index: ActivityName @@ -249,13 +249,13 @@ func (x *ActivityConf) Get4(activityId uint64, chapterId uint32, sectionId uint3 } // GetOrderedMap returns the 1-level ordered map. -func (x *ActivityConf) GetOrderedMap() *ProtoconfActivityConfActivityMap_OrderedMap { +func (x *ActivityConf) GetOrderedMap() *OrderedMap_ActivityConf_ActivityMap { return x.orderedMap } // GetOrderedMap1 finds value in the 1-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*ProtoconfActivityConfActivityChapterMap_OrderedMap, error) { +func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*OrderedMap_ActivityConf_Activity_ChapterMap, error) { conf := x.orderedMap if val, ok := conf.Get(activityId); !ok { return nil, fmt.Errorf("activityId(%v) %w", activityId, ErrNotFound) @@ -266,7 +266,7 @@ func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*ProtoconfActivityConf // GetOrderedMap2 finds value in the 2-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*ProtoconfActivityConfActivityChapterSectionMap_OrderedMap, error) { +func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*OrderedMap_ActivityConf_protoconf_SectionMap, error) { conf, err := x.GetOrderedMap1(activityId) if err != nil { return nil, err @@ -280,7 +280,7 @@ func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*Pro // GetOrderedMap3 finds value in the 3-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, sectionId uint32) (*ProtoconfSectionSectionRankMap_OrderedMap, error) { +func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, sectionId uint32) (*OrderedMap_ActivityConf_int32Map, error) { conf, err := x.GetOrderedMap2(activityId, chapterId) if err != nil { return nil, err @@ -296,7 +296,7 @@ func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, secti // FindActivityMap finds the index (ActivityName) to value (protoconf.ActivityConf_Activity) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindActivityMap() ActivityConf_Index_ActivityMap { +func (x *ActivityConf) FindActivityMap() Index_ActivityConf_ActivityMap { return x.indexActivityMap } @@ -319,7 +319,7 @@ func (x *ActivityConf) FindFirstActivity(activityName string) *protoconf.Activit // FindChapterMap finds the index (ChapterID) to value (protoconf.ActivityConf_Activity_Chapter) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindChapterMap() ActivityConf_Index_ChapterMap { +func (x *ActivityConf) FindChapterMap() Index_ActivityConf_ChapterMap { return x.indexChapterMap } @@ -342,7 +342,7 @@ func (x *ActivityConf) FindFirstChapter(chapterId uint32) *protoconf.ActivityCon // FindNamedChapterMap finds the index (ChapterName@NamedChapter) to value (protoconf.ActivityConf_Activity_Chapter) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindNamedChapterMap() ActivityConf_Index_NamedChapterMap { +func (x *ActivityConf) FindNamedChapterMap() Index_ActivityConf_NamedChapterMap { return x.indexNamedChapterMap } @@ -365,7 +365,7 @@ func (x *ActivityConf) FindFirstNamedChapter(chapterName string) *protoconf.Acti // FindAwardMap finds the index (SectionItemID@Award) to value (protoconf.Section_SectionItem) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindAwardMap() ActivityConf_Index_AwardMap { +func (x *ActivityConf) FindAwardMap() Index_ActivityConf_AwardMap { return x.indexAwardMap } @@ -561,32 +561,32 @@ func (x *ThemeConf) Get2(name string, param string) (string, error) { // Index types. // Index: ActivityID -type TaskConf_Index_TaskMap = map[int64][]*protoconf.TaskConf_Task +type Index_TaskConf_TaskMap = map[int64][]*protoconf.TaskConf_Task // OrderedIndex types. // OrderedIndex: Goal@OrderedTask -type TaskConf_OrderedIndex_OrderedTaskMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type OrderedIndex_TaskConf_OrderedTaskMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: Expiry@TaskExpiry -type TaskConf_OrderedIndex_TaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type OrderedIndex_TaskConf_TaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: Expiry@SortedTaskExpiry -type TaskConf_OrderedIndex_SortedTaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type OrderedIndex_TaskConf_SortedTaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry -type TaskConf_OrderedIndex_ActivityExpiryKey struct { +type OrderedIndex_TaskConf_ActivityExpiryKey struct { Expiry int64 ActivityId int64 } -func (x TaskConf_OrderedIndex_ActivityExpiryKey) Less(other TaskConf_OrderedIndex_ActivityExpiryKey) bool { +func (x OrderedIndex_TaskConf_ActivityExpiryKey) Less(other OrderedIndex_TaskConf_ActivityExpiryKey) bool { if x.Expiry != other.Expiry { return x.Expiry < other.Expiry } return x.ActivityId < other.ActivityId } -type TaskConf_OrderedIndex_ActivityExpiryMap = treemap.TreeMap[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task] +type OrderedIndex_TaskConf_ActivityExpiryMap = treemap.TreeMap[OrderedIndex_TaskConf_ActivityExpiryKey, []*protoconf.TaskConf_Task] // TaskConf is a wrapper around protobuf message: protoconf.TaskConf. // @@ -598,11 +598,11 @@ type TaskConf_OrderedIndex_ActivityExpiryMap = treemap.TreeMap[TaskConf_OrderedI type TaskConf struct { UnimplementedMessager data, originalData *protoconf.TaskConf - indexTaskMap TaskConf_Index_TaskMap - orderedIndexOrderedTaskMap *TaskConf_OrderedIndex_OrderedTaskMap - orderedIndexTaskExpiryMap *TaskConf_OrderedIndex_TaskExpiryMap - orderedIndexSortedTaskExpiryMap *TaskConf_OrderedIndex_SortedTaskExpiryMap - orderedIndexActivityExpiryMap *TaskConf_OrderedIndex_ActivityExpiryMap + indexTaskMap Index_TaskConf_TaskMap + orderedIndexOrderedTaskMap *OrderedIndex_TaskConf_OrderedTaskMap + orderedIndexTaskExpiryMap *OrderedIndex_TaskConf_TaskExpiryMap + orderedIndexSortedTaskExpiryMap *OrderedIndex_TaskConf_SortedTaskExpiryMap + orderedIndexActivityExpiryMap *OrderedIndex_TaskConf_ActivityExpiryMap } // Name returns the TaskConf's message name. @@ -665,7 +665,7 @@ func (x *TaskConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *TaskConf) processAfterLoad() error { // Index init. - x.indexTaskMap = make(TaskConf_Index_TaskMap) + x.indexTaskMap = make(Index_TaskConf_TaskMap) for _, item1 := range x.data.GetTaskMap() { { // Index: ActivityID @@ -686,7 +686,7 @@ func (x *TaskConf) processAfterLoad() error { x.orderedIndexOrderedTaskMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexSortedTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() - x.orderedIndexActivityExpiryMap = treemap.New2[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task]() + x.orderedIndexActivityExpiryMap = treemap.New2[OrderedIndex_TaskConf_ActivityExpiryKey, []*protoconf.TaskConf_Task]() for _, item1 := range x.data.GetTaskMap() { { // OrderedIndex: Goal@OrderedTask @@ -708,7 +708,7 @@ func (x *TaskConf) processAfterLoad() error { } { // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry - key := TaskConf_OrderedIndex_ActivityExpiryKey{item1.GetExpiry().GetSeconds(), item1.GetActivityId()} + key := OrderedIndex_TaskConf_ActivityExpiryKey{item1.GetExpiry().GetSeconds(), item1.GetActivityId()} value, _ := x.orderedIndexActivityExpiryMap.Get(key) x.orderedIndexActivityExpiryMap.Put(key, append(value, item1)) } @@ -748,7 +748,7 @@ func (x *TaskConf) Get1(id int64) (*protoconf.TaskConf_Task, error) { // FindTaskMap finds the index (ActivityID) to value (protoconf.TaskConf_Task) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindTaskMap() TaskConf_Index_TaskMap { +func (x *TaskConf) FindTaskMap() Index_TaskConf_TaskMap { return x.indexTaskMap } @@ -771,7 +771,7 @@ func (x *TaskConf) FindFirstTask(activityId int64) *protoconf.TaskConf_Task { // FindOrderedTaskMap finds the ordered index (Goal@OrderedTask) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindOrderedTaskMap() *TaskConf_OrderedIndex_OrderedTaskMap { +func (x *TaskConf) FindOrderedTaskMap() *OrderedIndex_TaskConf_OrderedTaskMap { return x.orderedIndexOrderedTaskMap } @@ -795,7 +795,7 @@ func (x *TaskConf) FindFirstOrderedTask(goal int64) *protoconf.TaskConf_Task { // FindTaskExpiryMap finds the ordered index (Expiry@TaskExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindTaskExpiryMap() *TaskConf_OrderedIndex_TaskExpiryMap { +func (x *TaskConf) FindTaskExpiryMap() *OrderedIndex_TaskConf_TaskExpiryMap { return x.orderedIndexTaskExpiryMap } @@ -819,7 +819,7 @@ func (x *TaskConf) FindFirstTaskExpiry(expiry int64) *protoconf.TaskConf_Task { // FindSortedTaskExpiryMap finds the ordered index (Expiry@SortedTaskExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindSortedTaskExpiryMap() *TaskConf_OrderedIndex_SortedTaskExpiryMap { +func (x *TaskConf) FindSortedTaskExpiryMap() *OrderedIndex_TaskConf_SortedTaskExpiryMap { return x.orderedIndexSortedTaskExpiryMap } @@ -843,13 +843,13 @@ func (x *TaskConf) FindFirstSortedTaskExpiry(expiry int64) *protoconf.TaskConf_T // FindActivityExpiryMap finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindActivityExpiryMap() *TaskConf_OrderedIndex_ActivityExpiryMap { +func (x *TaskConf) FindActivityExpiryMap() *OrderedIndex_TaskConf_ActivityExpiryMap { return x.orderedIndexActivityExpiryMap } // FindActivityExpiry finds a slice of all values of the given key. func (x *TaskConf) FindActivityExpiry(expiry int64, activityId int64) []*protoconf.TaskConf_Task { - val, _ := x.orderedIndexActivityExpiryMap.Get(TaskConf_OrderedIndex_ActivityExpiryKey{expiry, activityId}) + val, _ := x.orderedIndexActivityExpiryMap.Get(OrderedIndex_TaskConf_ActivityExpiryKey{expiry, activityId}) return val } From 4dc7b2bc6df2fac1491caf7e88e6678b03852519 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Fri, 14 Nov 2025 21:21:01 +0800 Subject: [PATCH 5/8] feat: simplify code --- .../helper/helper.go | 42 +++++++++---------- .../index/index.go | 22 +++++----- .../ordered_index/ordered_index.go | 19 ++++----- .../helper/helper.go | 22 ++++------ .../src/protoconf/item_conf.pc.h | 9 ++-- .../src/protoconf/test_conf.pc.h | 5 +-- 6 files changed, 49 insertions(+), 70 deletions(-) diff --git a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go index e606b93a..784f6f06 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go @@ -55,7 +55,7 @@ func ParseIndexFieldName(fd protoreflect.FieldDescriptor) string { return escapeIdentifier(string(fd.Name())) } -func ParseIndexFieldNameAsKeyStructFieldName(fd protoreflect.FieldDescriptor) string { +func ParseIndexFieldNameAsFuncParam(fd protoreflect.FieldDescriptor) string { if fd.IsList() { opts := fd.Options().(*descriptorpb.FieldOptions) fdOpts := proto.GetExtension(opts, tableaupb.E_Field).(*tableaupb.FieldOptions) @@ -64,10 +64,6 @@ func ParseIndexFieldNameAsKeyStructFieldName(fd protoreflect.FieldDescriptor) st return ParseIndexFieldName(fd) } -func ParseIndexFieldNameAsFuncParam(fd protoreflect.FieldDescriptor) string { - return ParseIndexFieldNameAsKeyStructFieldName(fd) -} - // ParseCppType converts a FieldDescriptor to C++ type string. func ParseCppType(fd protoreflect.FieldDescriptor) string { switch fd.Kind() { @@ -170,9 +166,8 @@ func ParseCppClassType(md protoreflect.MessageDescriptor) string { } type MapKey struct { - Type string - Name string - FieldName string + Type string + Name string } type MapKeys []MapKey @@ -195,26 +190,29 @@ func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { // GenGetParams generates function parameters, which are the names listed in the function's definition. func (keys MapKeys) GenGetParams() string { - var params string - for i, key := range keys { - params += ToConstRefType(key.Type) + " " + key.Name - if i != len(keys)-1 { - params += ", " - } + var params []string + for _, key := range keys { + params = append(params, ToConstRefType(key.Type)+" "+key.Name) } - return params + return strings.Join(params, ", ") } // GenGetArguments generates function arguments, which are the real values passed to the function. func (keys MapKeys) GenGetArguments() string { - var params string - for i, key := range keys { - params += key.Name - if i != len(keys)-1 { - params += ", " - } + var params []string + for _, key := range keys { + params = append(params, key.Name) + } + return strings.Join(params, ", ") +} + +// GenOtherArguments generates function arguments for other value of std::tie. +func (keys MapKeys) GenOtherArguments(other string) string { + var params []string + for _, key := range keys { + params = append(params, other+"."+key.Name) } - return params + return strings.Join(params, ", ") } func Indent(depth int) string { diff --git a/cmd/protoc-gen-cpp-tableau-loader/index/index.go b/cmd/protoc-gen-cpp-tableau-loader/index/index.go index ead69ce0..103d1d33 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/index/index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/index/index.go @@ -65,9 +65,8 @@ func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { var keys []helper.MapKey for _, field := range index.ColFields { keys = append(keys, helper.MapKey{ - Type: helper.ParseCppType(field.FD), - Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), - FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD), + Type: helper.ParseCppType(field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), }) } return keys @@ -107,28 +106,27 @@ func (x *Generator) GenHppIndexFinders() { hasher = ", " + keyHasherType // Generate key struct x.g.P(helper.Indent(1), "struct ", keyType, " {") - var equalities []string for _, key := range keys { - x.g.P(helper.Indent(2), key.Type, " ", key.FieldName, ";") - equalities = append(equalities, key.FieldName+" == other."+key.FieldName) + x.g.P(helper.Indent(2), key.Type, " ", key.Name, ";") } x.g.P("#if __cplusplus >= 202002L") x.g.P(helper.Indent(2), "bool operator==(const ", keyType, "& other) const = default;") x.g.P("#else") x.g.P(helper.Indent(2), "bool operator==(const ", keyType, "& other) const {") - x.g.P(helper.Indent(3), "return ", strings.Join(equalities, " && "), ";") + if len(keys) == 1 { + x.g.P(helper.Indent(3), "return ", keys[0].Name, " == other.", keys[0].Name, ";") + } else { + x.g.P(helper.Indent(3), "return std::tie(", keys.GenGetArguments(), ") == std::tie(", keys.GenOtherArguments("other"), ");") + } + // x.g.P(helper.Indent(3), "return ", strings.Join(equalities, " && "), ";") x.g.P(helper.Indent(2), "}") x.g.P("#endif") x.g.P(helper.Indent(1), "};") // Generate key hasher struct x.g.P(helper.Indent(1), "struct ", keyHasherType, " {") - var combinedKeys []string - for _, key := range keys { - combinedKeys = append(combinedKeys, "key."+key.FieldName) - } x.g.P(helper.Indent(2), "std::size_t operator()(const ", keyType, "& key) const {") - x.g.P(helper.Indent(3), "return util::SugaredHashCombine(", strings.Join(combinedKeys, ", "), ");") + x.g.P(helper.Indent(3), "return util::SugaredHashCombine(", keys.GenOtherArguments("key"), ");") x.g.P(helper.Indent(2), "}") x.g.P(helper.Indent(1), "};") } diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go index e3538e34..de05bbd4 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go @@ -65,9 +65,8 @@ func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { var keys []helper.MapKey for _, field := range index.ColFields { keys = append(keys, helper.MapKey{ - Type: helper.ParseOrderedMapKeyType(field.FD), - Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), - FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(field.FD), + Type: helper.ParseOrderedMapKeyType(field.FD), + Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), }) } return keys @@ -111,20 +110,16 @@ func (x *Generator) GenHppOrderedIndexFinders() { // Generate key struct x.g.P(helper.Indent(1), "struct ", keyType, " {") for _, key := range keys { - x.g.P(helper.Indent(2), key.Type, " ", key.FieldName, ";") + x.g.P(helper.Indent(2), key.Type, " ", key.Name, ";") } x.g.P("#if __cplusplus >= 202002L") x.g.P(helper.Indent(2), "auto operator<=>(const ", keyType, "& other) const = default;") x.g.P("#else") x.g.P(helper.Indent(2), "bool operator<(const ", keyType, "& other) const {") - for i, key := range keys { - if i == len(keys)-1 { - x.g.P(helper.Indent(3), "return ", key.FieldName, " < other.", key.FieldName, ";") - } else { - x.g.P(helper.Indent(3), "if (", key.FieldName, " != other.", key.FieldName, ") {") - x.g.P(helper.Indent(4), "return ", key.FieldName, " < other.", key.FieldName, ";") - x.g.P(helper.Indent(3), "}") - } + if len(keys) == 1 { + x.g.P(helper.Indent(3), "return ", keys[0].Name, " < other.", keys[0].Name, ";") + } else { + x.g.P(helper.Indent(3), "return std::tie(", keys.GenGetArguments(), ") < std::tie(", keys.GenOtherArguments("other"), ");") } x.g.P(helper.Indent(2), "}") x.g.P("#endif") diff --git a/cmd/protoc-gen-go-tableau-loader/helper/helper.go b/cmd/protoc-gen-go-tableau-loader/helper/helper.go index f874f5bf..7dd23fcd 100644 --- a/cmd/protoc-gen-go-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-go-tableau-loader/helper/helper.go @@ -267,24 +267,18 @@ func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { // GenGetParams generates function parameters, which are the names listed in the function's definition. func (keys MapKeys) GenGetParams() string { - var params string - for i, key := range keys { - params += key.Name + " " + key.Type - if i != len(keys)-1 { - params += ", " - } + var params []string + for _, key := range keys { + params = append(params, key.Name+" "+key.Type) } - return params + return strings.Join(params, ", ") } // GenGetArguments generates function arguments, which are the real values passed to the function. func (keys MapKeys) GenGetArguments() string { - var params string - for i, key := range keys { - params += key.Name - if i != len(keys)-1 { - params += ", " - } + var params []string + for _, key := range keys { + params = append(params, key.Name) } - return params + return strings.Join(params, ", ") } diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h index a468f7c3..5bc8ec57 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h @@ -108,7 +108,7 @@ class ItemConf : public Messager { bool operator==(const Index_AwardItemKey& other) const = default; #else bool operator==(const Index_AwardItemKey& other) const { - return id == other.id && name == other.name; + return std::tie(id, name) == std::tie(other.id, other.name); } #endif }; @@ -141,7 +141,7 @@ class ItemConf : public Messager { bool operator==(const Index_SpecialItemKey& other) const = default; #else bool operator==(const Index_SpecialItemKey& other) const { - return id == other.id && type == other.type && param == other.param && ext_type == other.ext_type; + return std::tie(id, type, param, ext_type) == std::tie(other.id, other.type, other.param, other.ext_type); } #endif }; @@ -248,10 +248,7 @@ class ItemConf : public Messager { auto operator<=>(const OrderedIndex_ParamExtTypeKey& other) const = default; #else bool operator<(const OrderedIndex_ParamExtTypeKey& other) const { - if (param != other.param) { - return param < other.param; - } - return ext_type < other.ext_type; + return std::tie(param, ext_type) < std::tie(other.param, other.ext_type); } #endif }; diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h index 005de675..837d9da4 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h @@ -235,10 +235,7 @@ class TaskConf : public Messager { auto operator<=>(const OrderedIndex_ActivityExpiryKey& other) const = default; #else bool operator<(const OrderedIndex_ActivityExpiryKey& other) const { - if (expiry != other.expiry) { - return expiry < other.expiry; - } - return activity_id < other.activity_id; + return std::tie(expiry, activity_id) < std::tie(other.expiry, other.activity_id); } #endif }; From c26140d3563131ade7ce9391d6eb4e622b9fbee9 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Sat, 15 Nov 2025 15:54:39 +0800 Subject: [PATCH 6/8] feat: remove Map suffix for cpp index & ordered index --- .../index/index.go | 4 ++-- .../ordered_index/ordered_index.go | 4 ++-- .../src/protoconf/item_conf.pc.cc | 24 +++++++++---------- .../src/protoconf/item_conf.pc.h | 24 +++++++++---------- .../src/protoconf/test_conf.pc.cc | 18 +++++++------- .../src/protoconf/test_conf.pc.h | 18 +++++++------- 6 files changed, 46 insertions(+), 46 deletions(-) diff --git a/cmd/protoc-gen-cpp-tableau-loader/index/index.go b/cmd/protoc-gen-cpp-tableau-loader/index/index.go index 103d1d33..c2822f72 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/index/index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/index/index.go @@ -134,7 +134,7 @@ func (x *Generator) GenHppIndexFinders() { x.g.P(helper.Indent(1), "using ", mapType, " = std::unordered_map<", keyType, ", ", vectorType, hasher, ">;") x.g.P(helper.Indent(1), "// Finds the index (", index.Index, ") to value (", vectorType, ") hash map.") x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") @@ -277,7 +277,7 @@ func (x *Generator) GenCppIndexFinders() { messagerName := x.messagerName() x.g.P("// Index: ", index.Index) - x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "Map() const { return ", indexContainerName, " ;}") + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") x.g.P() keys := x.indexKeys(index) diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go index de05bbd4..619a40f6 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go @@ -129,7 +129,7 @@ func (x *Generator) GenHppOrderedIndexFinders() { x.g.P(helper.Indent(1), "using ", mapType, " = std::map<", keyType, ", ", vectorType, ">;") x.g.P(helper.Indent(1), "// Finds the ordered index (", index.Index, ") to value (", vectorType, ") map.") x.g.P(helper.Indent(1), "// One key may correspond to multiple values, which are contained by a vector.") - x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "Map() const;") + x.g.P(helper.Indent(1), "const ", mapType, "& Find", index.Name(), "() const;") x.g.P(helper.Indent(1), "// Finds a vector of all values of the given key(s).") x.g.P(helper.Indent(1), "const ", vectorType, "* Find", index.Name(), "(", keys.GenGetParams(), ") const;") x.g.P(helper.Indent(1), "// Finds the first value of the given key(s).") @@ -274,7 +274,7 @@ func (x *Generator) GenCppOrderedIndexFinders() { messagerName := x.messagerName() x.g.P("// OrderedIndex: ", index.Index) - x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "Map() const { return ", indexContainerName, " ;}") + x.g.P("const ", messagerName, "::", mapType, "& ", messagerName, "::Find", index.Name(), "() const { return ", indexContainerName, " ;}") x.g.P() keys := x.indexKeys(index) diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc index 15fee8e3..2e3ceff6 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.cc @@ -151,7 +151,7 @@ const ItemConf::OrderedMap_ItemMap* ItemConf::GetOrderedMap() const { } // Index: Type -const ItemConf::Index_ItemMap& ItemConf::FindItemMap() const { return index_item_map_ ;} +const ItemConf::Index_ItemMap& ItemConf::FindItem() const { return index_item_map_ ;} const ItemConf::Index_ItemVector* ItemConf::FindItem(protoconf::FruitType type) const { auto iter = index_item_map_.find(type); @@ -170,7 +170,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItem(protoconf::FruitType ty } // Index: Param@ItemInfo -const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfoMap() const { return index_item_info_map_ ;} +const ItemConf::Index_ItemInfoMap& ItemConf::FindItemInfo() const { return index_item_info_map_ ;} const ItemConf::Index_ItemInfoVector* ItemConf::FindItemInfo(int32_t param) const { auto iter = index_item_info_map_.find(param); @@ -189,7 +189,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemInfo(int32_t param) cons } // Index: Default@ItemDefaultInfo -const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfoMap() const { return index_item_default_info_map_ ;} +const ItemConf::Index_ItemDefaultInfoMap& ItemConf::FindItemDefaultInfo() const { return index_item_default_info_map_ ;} const ItemConf::Index_ItemDefaultInfoVector* ItemConf::FindItemDefaultInfo(const std::string& default_) const { auto iter = index_item_default_info_map_.find(default_); @@ -208,7 +208,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemDefaultInfo(const std::s } // Index: ExtType@ItemExtInfo -const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfoMap() const { return index_item_ext_info_map_ ;} +const ItemConf::Index_ItemExtInfoMap& ItemConf::FindItemExtInfo() const { return index_item_ext_info_map_ ;} const ItemConf::Index_ItemExtInfoVector* ItemConf::FindItemExtInfo(protoconf::FruitType ext_type) const { auto iter = index_item_ext_info_map_.find(ext_type); @@ -227,7 +227,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemExtInfo(protoconf::Fruit } // Index: (ID,Name)@AwardItem -const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItemMap() const { return index_award_item_map_ ;} +const ItemConf::Index_AwardItemMap& ItemConf::FindAwardItem() const { return index_award_item_map_ ;} const ItemConf::Index_AwardItemVector* ItemConf::FindAwardItem(uint32_t id, const std::string& name) const { auto iter = index_award_item_map_.find({id, name}); @@ -246,7 +246,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstAwardItem(uint32_t id, const } // Index: (ID,Type,Param,ExtType)@SpecialItem -const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItemMap() const { return index_special_item_map_ ;} +const ItemConf::Index_SpecialItemMap& ItemConf::FindSpecialItem() const { return index_special_item_map_ ;} const ItemConf::Index_SpecialItemVector* ItemConf::FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const { auto iter = index_special_item_map_.find({id, type, param, ext_type}); @@ -265,7 +265,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstSpecialItem(uint32_t id, pro } // Index: PathDir@ItemPathDir -const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDirMap() const { return index_item_path_dir_map_ ;} +const ItemConf::Index_ItemPathDirMap& ItemConf::FindItemPathDir() const { return index_item_path_dir_map_ ;} const ItemConf::Index_ItemPathDirVector* ItemConf::FindItemPathDir(const std::string& dir) const { auto iter = index_item_path_dir_map_.find(dir); @@ -284,7 +284,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathDir(const std::strin } // Index: PathName@ItemPathName -const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathNameMap() const { return index_item_path_name_map_ ;} +const ItemConf::Index_ItemPathNameMap& ItemConf::FindItemPathName() const { return index_item_path_name_map_ ;} const ItemConf::Index_ItemPathNameVector* ItemConf::FindItemPathName(const std::string& name) const { auto iter = index_item_path_name_map_.find(name); @@ -303,7 +303,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathName(const std::stri } // Index: PathFriendID@ItemPathFriendID -const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendIDMap() const { return index_item_path_friend_id_map_ ;} +const ItemConf::Index_ItemPathFriendIDMap& ItemConf::FindItemPathFriendID() const { return index_item_path_friend_id_map_ ;} const ItemConf::Index_ItemPathFriendIDVector* ItemConf::FindItemPathFriendID(uint32_t id) const { auto iter = index_item_path_friend_id_map_.find(id); @@ -322,7 +322,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstItemPathFriendID(uint32_t id } // Index: UseEffectType@UseEffectType -const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectTypeMap() const { return index_use_effect_type_map_ ;} +const ItemConf::Index_UseEffectTypeMap& ItemConf::FindUseEffectType() const { return index_use_effect_type_map_ ;} const ItemConf::Index_UseEffectTypeVector* ItemConf::FindUseEffectType(protoconf::UseEffect::Type type) const { auto iter = index_use_effect_type_map_.find(type); @@ -341,7 +341,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstUseEffectType(protoconf::Use } // OrderedIndex: ExtType@ExtType -const ItemConf::OrderedIndex_ExtTypeMap& ItemConf::FindExtTypeMap() const { return ordered_index_ext_type_map_ ;} +const ItemConf::OrderedIndex_ExtTypeMap& ItemConf::FindExtType() const { return ordered_index_ext_type_map_ ;} const ItemConf::OrderedIndex_ExtTypeVector* ItemConf::FindExtType(protoconf::FruitType ext_type) const { auto iter = ordered_index_ext_type_map_.find(ext_type); @@ -360,7 +360,7 @@ const protoconf::ItemConf::Item* ItemConf::FindFirstExtType(protoconf::FruitType } // OrderedIndex: (Param,ExtType)@ParamExtType -const ItemConf::OrderedIndex_ParamExtTypeMap& ItemConf::FindParamExtTypeMap() const { return ordered_index_param_ext_type_map_ ;} +const ItemConf::OrderedIndex_ParamExtTypeMap& ItemConf::FindParamExtType() const { return ordered_index_param_ext_type_map_ ;} const ItemConf::OrderedIndex_ParamExtTypeVector* ItemConf::FindParamExtType(int32_t param, protoconf::FruitType ext_type) const { auto iter = ordered_index_param_ext_type_map_.find({param, ext_type}); diff --git a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h index 5bc8ec57..56d1bff8 100644 --- a/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/item_conf.pc.h @@ -45,7 +45,7 @@ class ItemConf : public Messager { using Index_ItemMap = std::unordered_map; // Finds the index (Type) to value (Index_ItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemMap& FindItemMap() const; + const Index_ItemMap& FindItem() const; // Finds a vector of all values of the given key(s). const Index_ItemVector* FindItem(protoconf::FruitType type) const; // Finds the first value of the given key(s). @@ -60,7 +60,7 @@ class ItemConf : public Messager { using Index_ItemInfoMap = std::unordered_map; // Finds the index (Param@ItemInfo) to value (Index_ItemInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemInfoMap& FindItemInfoMap() const; + const Index_ItemInfoMap& FindItemInfo() const; // Finds a vector of all values of the given key(s). const Index_ItemInfoVector* FindItemInfo(int32_t param) const; // Finds the first value of the given key(s). @@ -75,7 +75,7 @@ class ItemConf : public Messager { using Index_ItemDefaultInfoMap = std::unordered_map; // Finds the index (Default@ItemDefaultInfo) to value (Index_ItemDefaultInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemDefaultInfoMap& FindItemDefaultInfoMap() const; + const Index_ItemDefaultInfoMap& FindItemDefaultInfo() const; // Finds a vector of all values of the given key(s). const Index_ItemDefaultInfoVector* FindItemDefaultInfo(const std::string& default_) const; // Finds the first value of the given key(s). @@ -90,7 +90,7 @@ class ItemConf : public Messager { using Index_ItemExtInfoMap = std::unordered_map; // Finds the index (ExtType@ItemExtInfo) to value (Index_ItemExtInfoVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemExtInfoMap& FindItemExtInfoMap() const; + const Index_ItemExtInfoMap& FindItemExtInfo() const; // Finds a vector of all values of the given key(s). const Index_ItemExtInfoVector* FindItemExtInfo(protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -121,7 +121,7 @@ class ItemConf : public Messager { using Index_AwardItemMap = std::unordered_map; // Finds the index ((ID,Name)@AwardItem) to value (Index_AwardItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardItemMap& FindAwardItemMap() const; + const Index_AwardItemMap& FindAwardItem() const; // Finds a vector of all values of the given key(s). const Index_AwardItemVector* FindAwardItem(uint32_t id, const std::string& name) const; // Finds the first value of the given key(s). @@ -154,7 +154,7 @@ class ItemConf : public Messager { using Index_SpecialItemMap = std::unordered_map; // Finds the index ((ID,Type,Param,ExtType)@SpecialItem) to value (Index_SpecialItemVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_SpecialItemMap& FindSpecialItemMap() const; + const Index_SpecialItemMap& FindSpecialItem() const; // Finds a vector of all values of the given key(s). const Index_SpecialItemVector* FindSpecialItem(uint32_t id, protoconf::FruitType type, int32_t param, protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -169,7 +169,7 @@ class ItemConf : public Messager { using Index_ItemPathDirMap = std::unordered_map; // Finds the index (PathDir@ItemPathDir) to value (Index_ItemPathDirVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathDirMap& FindItemPathDirMap() const; + const Index_ItemPathDirMap& FindItemPathDir() const; // Finds a vector of all values of the given key(s). const Index_ItemPathDirVector* FindItemPathDir(const std::string& dir) const; // Finds the first value of the given key(s). @@ -184,7 +184,7 @@ class ItemConf : public Messager { using Index_ItemPathNameMap = std::unordered_map; // Finds the index (PathName@ItemPathName) to value (Index_ItemPathNameVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathNameMap& FindItemPathNameMap() const; + const Index_ItemPathNameMap& FindItemPathName() const; // Finds a vector of all values of the given key(s). const Index_ItemPathNameVector* FindItemPathName(const std::string& name) const; // Finds the first value of the given key(s). @@ -199,7 +199,7 @@ class ItemConf : public Messager { using Index_ItemPathFriendIDMap = std::unordered_map; // Finds the index (PathFriendID@ItemPathFriendID) to value (Index_ItemPathFriendIDVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ItemPathFriendIDMap& FindItemPathFriendIDMap() const; + const Index_ItemPathFriendIDMap& FindItemPathFriendID() const; // Finds a vector of all values of the given key(s). const Index_ItemPathFriendIDVector* FindItemPathFriendID(uint32_t id) const; // Finds the first value of the given key(s). @@ -214,7 +214,7 @@ class ItemConf : public Messager { using Index_UseEffectTypeMap = std::unordered_map; // Finds the index (UseEffectType@UseEffectType) to value (Index_UseEffectTypeVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_UseEffectTypeMap& FindUseEffectTypeMap() const; + const Index_UseEffectTypeMap& FindUseEffectType() const; // Finds a vector of all values of the given key(s). const Index_UseEffectTypeVector* FindUseEffectType(protoconf::UseEffect::Type type) const; // Finds the first value of the given key(s). @@ -230,7 +230,7 @@ class ItemConf : public Messager { using OrderedIndex_ExtTypeMap = std::map; // Finds the ordered index (ExtType@ExtType) to value (OrderedIndex_ExtTypeVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ExtTypeMap& FindExtTypeMap() const; + const OrderedIndex_ExtTypeMap& FindExtType() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ExtTypeVector* FindExtType(protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). @@ -256,7 +256,7 @@ class ItemConf : public Messager { using OrderedIndex_ParamExtTypeMap = std::map; // Finds the ordered index ((Param,ExtType)@ParamExtType) to value (OrderedIndex_ParamExtTypeVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ParamExtTypeMap& FindParamExtTypeMap() const; + const OrderedIndex_ParamExtTypeMap& FindParamExtType() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ParamExtTypeVector* FindParamExtType(int32_t param, protoconf::FruitType ext_type) const; // Finds the first value of the given key(s). diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc index 2bf19eee..1018fd65 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.cc @@ -162,7 +162,7 @@ const ActivityConf::OrderedMap_int32Map* ActivityConf::GetOrderedMap(uint64_t ac } // Index: ActivityName -const ActivityConf::Index_ActivityMap& ActivityConf::FindActivityMap() const { return index_activity_map_ ;} +const ActivityConf::Index_ActivityMap& ActivityConf::FindActivity() const { return index_activity_map_ ;} const ActivityConf::Index_ActivityVector* ActivityConf::FindActivity(const std::string& activity_name) const { auto iter = index_activity_map_.find(activity_name); @@ -181,7 +181,7 @@ const protoconf::ActivityConf::Activity* ActivityConf::FindFirstActivity(const s } // Index: ChapterID -const ActivityConf::Index_ChapterMap& ActivityConf::FindChapterMap() const { return index_chapter_map_ ;} +const ActivityConf::Index_ChapterMap& ActivityConf::FindChapter() const { return index_chapter_map_ ;} const ActivityConf::Index_ChapterVector* ActivityConf::FindChapter(uint32_t chapter_id) const { auto iter = index_chapter_map_.find(chapter_id); @@ -200,7 +200,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstChapter } // Index: ChapterName@NamedChapter -const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapterMap() const { return index_named_chapter_map_ ;} +const ActivityConf::Index_NamedChapterMap& ActivityConf::FindNamedChapter() const { return index_named_chapter_map_ ;} const ActivityConf::Index_NamedChapterVector* ActivityConf::FindNamedChapter(const std::string& chapter_name) const { auto iter = index_named_chapter_map_.find(chapter_name); @@ -219,7 +219,7 @@ const protoconf::ActivityConf::Activity::Chapter* ActivityConf::FindFirstNamedCh } // Index: SectionItemID@Award -const ActivityConf::Index_AwardMap& ActivityConf::FindAwardMap() const { return index_award_map_ ;} +const ActivityConf::Index_AwardMap& ActivityConf::FindAward() const { return index_award_map_ ;} const ActivityConf::Index_AwardVector* ActivityConf::FindAward(uint32_t id) const { auto iter = index_award_map_.find(id); @@ -367,7 +367,7 @@ const protoconf::TaskConf::Task* TaskConf::Get(int64_t id) const { } // Index: ActivityID -const TaskConf::Index_TaskMap& TaskConf::FindTaskMap() const { return index_task_map_ ;} +const TaskConf::Index_TaskMap& TaskConf::FindTask() const { return index_task_map_ ;} const TaskConf::Index_TaskVector* TaskConf::FindTask(int64_t activity_id) const { auto iter = index_task_map_.find(activity_id); @@ -386,7 +386,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstTask(int64_t activity_id) co } // OrderedIndex: Goal@OrderedTask -const TaskConf::OrderedIndex_OrderedTaskMap& TaskConf::FindOrderedTaskMap() const { return ordered_index_ordered_task_map_ ;} +const TaskConf::OrderedIndex_OrderedTaskMap& TaskConf::FindOrderedTask() const { return ordered_index_ordered_task_map_ ;} const TaskConf::OrderedIndex_OrderedTaskVector* TaskConf::FindOrderedTask(int64_t goal) const { auto iter = ordered_index_ordered_task_map_.find(goal); @@ -405,7 +405,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstOrderedTask(int64_t goal) co } // OrderedIndex: Expiry@TaskExpiry -const TaskConf::OrderedIndex_TaskExpiryMap& TaskConf::FindTaskExpiryMap() const { return ordered_index_task_expiry_map_ ;} +const TaskConf::OrderedIndex_TaskExpiryMap& TaskConf::FindTaskExpiry() const { return ordered_index_task_expiry_map_ ;} const TaskConf::OrderedIndex_TaskExpiryVector* TaskConf::FindTaskExpiry(int64_t expiry) const { auto iter = ordered_index_task_expiry_map_.find(expiry); @@ -424,7 +424,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstTaskExpiry(int64_t expiry) c } // OrderedIndex: Expiry@SortedTaskExpiry -const TaskConf::OrderedIndex_SortedTaskExpiryMap& TaskConf::FindSortedTaskExpiryMap() const { return ordered_index_sorted_task_expiry_map_ ;} +const TaskConf::OrderedIndex_SortedTaskExpiryMap& TaskConf::FindSortedTaskExpiry() const { return ordered_index_sorted_task_expiry_map_ ;} const TaskConf::OrderedIndex_SortedTaskExpiryVector* TaskConf::FindSortedTaskExpiry(int64_t expiry) const { auto iter = ordered_index_sorted_task_expiry_map_.find(expiry); @@ -443,7 +443,7 @@ const protoconf::TaskConf::Task* TaskConf::FindFirstSortedTaskExpiry(int64_t exp } // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry -const TaskConf::OrderedIndex_ActivityExpiryMap& TaskConf::FindActivityExpiryMap() const { return ordered_index_activity_expiry_map_ ;} +const TaskConf::OrderedIndex_ActivityExpiryMap& TaskConf::FindActivityExpiry() const { return ordered_index_activity_expiry_map_ ;} const TaskConf::OrderedIndex_ActivityExpiryVector* TaskConf::FindActivityExpiry(int64_t expiry, int64_t activity_id) const { auto iter = ordered_index_activity_expiry_map_.find({expiry, activity_id}); diff --git a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h index 837d9da4..7a9f2273 100644 --- a/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h +++ b/test/cpp-tableau-loader/src/protoconf/test_conf.pc.h @@ -60,7 +60,7 @@ class ActivityConf : public Messager { using Index_ActivityMap = std::unordered_map; // Finds the index (ActivityName) to value (Index_ActivityVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ActivityMap& FindActivityMap() const; + const Index_ActivityMap& FindActivity() const; // Finds a vector of all values of the given key(s). const Index_ActivityVector* FindActivity(const std::string& activity_name) const; // Finds the first value of the given key(s). @@ -75,7 +75,7 @@ class ActivityConf : public Messager { using Index_ChapterMap = std::unordered_map; // Finds the index (ChapterID) to value (Index_ChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_ChapterMap& FindChapterMap() const; + const Index_ChapterMap& FindChapter() const; // Finds a vector of all values of the given key(s). const Index_ChapterVector* FindChapter(uint32_t chapter_id) const; // Finds the first value of the given key(s). @@ -90,7 +90,7 @@ class ActivityConf : public Messager { using Index_NamedChapterMap = std::unordered_map; // Finds the index (ChapterName@NamedChapter) to value (Index_NamedChapterVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_NamedChapterMap& FindNamedChapterMap() const; + const Index_NamedChapterMap& FindNamedChapter() const; // Finds a vector of all values of the given key(s). const Index_NamedChapterVector* FindNamedChapter(const std::string& chapter_name) const; // Finds the first value of the given key(s). @@ -105,7 +105,7 @@ class ActivityConf : public Messager { using Index_AwardMap = std::unordered_map; // Finds the index (SectionItemID@Award) to value (Index_AwardVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_AwardMap& FindAwardMap() const; + const Index_AwardMap& FindAward() const; // Finds a vector of all values of the given key(s). const Index_AwardVector* FindAward(uint32_t id) const; // Finds the first value of the given key(s). @@ -171,7 +171,7 @@ class TaskConf : public Messager { using Index_TaskMap = std::unordered_map; // Finds the index (ActivityID) to value (Index_TaskVector) hash map. // One key may correspond to multiple values, which are contained by a vector. - const Index_TaskMap& FindTaskMap() const; + const Index_TaskMap& FindTask() const; // Finds a vector of all values of the given key(s). const Index_TaskVector* FindTask(int64_t activity_id) const; // Finds the first value of the given key(s). @@ -187,7 +187,7 @@ class TaskConf : public Messager { using OrderedIndex_OrderedTaskMap = std::map; // Finds the ordered index (Goal@OrderedTask) to value (OrderedIndex_OrderedTaskVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_OrderedTaskMap& FindOrderedTaskMap() const; + const OrderedIndex_OrderedTaskMap& FindOrderedTask() const; // Finds a vector of all values of the given key(s). const OrderedIndex_OrderedTaskVector* FindOrderedTask(int64_t goal) const; // Finds the first value of the given key(s). @@ -202,7 +202,7 @@ class TaskConf : public Messager { using OrderedIndex_TaskExpiryMap = std::map; // Finds the ordered index (Expiry@TaskExpiry) to value (OrderedIndex_TaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_TaskExpiryMap& FindTaskExpiryMap() const; + const OrderedIndex_TaskExpiryMap& FindTaskExpiry() const; // Finds a vector of all values of the given key(s). const OrderedIndex_TaskExpiryVector* FindTaskExpiry(int64_t expiry) const; // Finds the first value of the given key(s). @@ -217,7 +217,7 @@ class TaskConf : public Messager { using OrderedIndex_SortedTaskExpiryMap = std::map; // Finds the ordered index (Expiry@SortedTaskExpiry) to value (OrderedIndex_SortedTaskExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_SortedTaskExpiryMap& FindSortedTaskExpiryMap() const; + const OrderedIndex_SortedTaskExpiryMap& FindSortedTaskExpiry() const; // Finds a vector of all values of the given key(s). const OrderedIndex_SortedTaskExpiryVector* FindSortedTaskExpiry(int64_t expiry) const; // Finds the first value of the given key(s). @@ -243,7 +243,7 @@ class TaskConf : public Messager { using OrderedIndex_ActivityExpiryMap = std::map; // Finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (OrderedIndex_ActivityExpiryVector) map. // One key may correspond to multiple values, which are contained by a vector. - const OrderedIndex_ActivityExpiryMap& FindActivityExpiryMap() const; + const OrderedIndex_ActivityExpiryMap& FindActivityExpiry() const; // Finds a vector of all values of the given key(s). const OrderedIndex_ActivityExpiryVector* FindActivityExpiry(int64_t expiry, int64_t activity_id) const; // Finds the first value of the given key(s). From 1b70c6e61f3ab6c933fd16aee4b5aa9d2e06a568 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Mon, 17 Nov 2025 22:22:15 +0800 Subject: [PATCH 7/8] feat: cr --- .../helper/helper.go | 7 +- .../index/index.go | 16 +-- cmd/protoc-gen-cpp-tableau-loader/messager.go | 4 +- .../ordered_index/ordered_index.go | 20 +-- .../ordered_map/ordered_map.go | 8 +- .../helper/helper.go | 7 +- .../index/index.go | 22 ++-- .../ordered_index/ordered_index.go | 26 ++-- .../ordered_map/ordered_map.go | 14 +- .../protoconf/loader/hero_conf.pc.go | 24 ++-- .../protoconf/loader/item_conf.pc.go | 122 +++++++++--------- .../protoconf/loader/test_conf.pc.go | 110 ++++++++-------- 12 files changed, 189 insertions(+), 191 deletions(-) diff --git a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go index 784f6f06..e136cc36 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-cpp-tableau-loader/helper/helper.go @@ -120,9 +120,9 @@ func ParseMapKeyType(fd protoreflect.FieldDescriptor) string { } } -// ParseOrderedMapKeyType converts a FieldDescriptor to its treemap key type. +// ParseOrderedIndexKeyType converts a FieldDescriptor to its treemap key type. // fd must be an ordered type, or a message which can be converted to an ordered type. -func ParseOrderedMapKeyType(fd protoreflect.FieldDescriptor) string { +func ParseOrderedIndexKeyType(fd protoreflect.FieldDescriptor) string { switch fd.Kind() { case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return "int32_t" @@ -184,8 +184,7 @@ func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { } } } - keys = append(keys, newKey) - return keys + return append(keys, newKey) } // GenGetParams generates function parameters, which are the names listed in the function's definition. diff --git a/cmd/protoc-gen-cpp-tableau-loader/index/index.go b/cmd/protoc-gen-cpp-tableau-loader/index/index.go index c2822f72..14f4562a 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/index/index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/index/index.go @@ -26,7 +26,7 @@ func NewGenerator(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, } } -func (x *Generator) Generate() bool { +func (x *Generator) NeedGenerate() bool { return options.NeedGenIndex(x.message.Desc, options.LangCPP) } @@ -62,9 +62,9 @@ func (x *Generator) indexContainerName(index *index.LevelIndex) string { } func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { - var keys []helper.MapKey + var keys helper.MapKeys for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ + keys = keys.AddMapKey(helper.MapKey{ Type: helper.ParseCppType(field.FD), Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), }) @@ -85,7 +85,7 @@ func (x *Generator) parseKeyFieldName(field *index.LevelField) string { } func (x *Generator) GenHppIndexFinders() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P() @@ -148,7 +148,7 @@ func (x *Generator) GenHppIndexFinders() { } func (x *Generator) GenCppIndexLoader() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P(helper.Indent(1), "// Index init.") @@ -229,12 +229,12 @@ func (x *Generator) generateOneCppMulticolumnIndex(depth int, index *index.Level if field.FD.Enum() != nil { key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" } - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneCppMulticolumnIndex(depth+1, index, parentDataName, keys) x.g.P(helper.Indent(depth+1), "}") } else { key := parentDataName + fieldName - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneCppMulticolumnIndex(depth, index, parentDataName, keys) } } @@ -266,7 +266,7 @@ func (x *Generator) genIndexSorter() { } func (x *Generator) GenCppIndexFinders() { - if !x.Generate() { + if !x.NeedGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { diff --git a/cmd/protoc-gen-cpp-tableau-loader/messager.go b/cmd/protoc-gen-cpp-tableau-loader/messager.go index 8c38dbbc..fb35ca1f 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/messager.go +++ b/cmd/protoc-gen-cpp-tableau-loader/messager.go @@ -96,7 +96,7 @@ func genHppMessage(g *protogen.GeneratedFile, message *protogen.Message) { g.P(helper.Indent(1), "const google::protobuf::Message* Message() const override { return &data_; }") g.P() - if orderedMapGenerator.Generate() || indexGenerator.Generate() || orderedIndexGenerator.Generate() { + if orderedMapGenerator.NeedGenerate() || indexGenerator.NeedGenerate() || orderedIndexGenerator.NeedGenerate() { g.P(" private:") g.P(helper.Indent(1), "virtual bool ProcessAfterLoad() override final;") g.P() @@ -175,7 +175,7 @@ func genCppMessage(g *protogen.GeneratedFile, message *protogen.Message) { g.P("}") g.P() - if orderedMapGenerator.Generate() || indexGenerator.Generate() || orderedIndexGenerator.Generate() { + if orderedMapGenerator.NeedGenerate() || indexGenerator.NeedGenerate() || orderedIndexGenerator.NeedGenerate() { g.P("bool ", messagerName, "::ProcessAfterLoad() {") orderedMapGenerator.GenOrderedMapLoader() indexGenerator.GenCppIndexLoader() diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go index 619a40f6..7650a389 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go @@ -26,7 +26,7 @@ func NewGenerator(g *protogen.GeneratedFile, descriptor *index.IndexDescriptor, } } -func (x *Generator) Generate() bool { +func (x *Generator) NeedGenerate() bool { return options.NeedGenOrderedIndex(x.message.Desc, options.LangCPP) } @@ -42,7 +42,7 @@ func (x *Generator) mapKeyType(index *index.LevelIndex) string { if len(index.ColFields) == 1 { // single-column index field := index.ColFields[0] // just take first field - return helper.ParseOrderedMapKeyType(field.FD) + return helper.ParseOrderedIndexKeyType(field.FD) } else { // multi-column index return fmt.Sprintf("OrderedIndex_%sKey", index.Name()) @@ -62,10 +62,10 @@ func (x *Generator) indexContainerName(index *index.LevelIndex) string { } func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { - var keys []helper.MapKey + var keys helper.MapKeys for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ - Type: helper.ParseOrderedMapKeyType(field.FD), + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseOrderedIndexKeyType(field.FD), Name: helper.ParseIndexFieldNameAsFuncParam(field.FD), }) } @@ -92,7 +92,7 @@ func (x *Generator) parseKeyFieldNameAndSuffix(field *index.LevelField) (string, } func (x *Generator) GenHppOrderedIndexFinders() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P(helper.Indent(1), "// OrderedIndex accessers.") @@ -144,7 +144,7 @@ func (x *Generator) GenHppOrderedIndexFinders() { } func (x *Generator) GenCppOrderedIndexLoader() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P(helper.Indent(1), "// OrderedIndex init.") @@ -225,12 +225,12 @@ func (x *Generator) generateOneCppMulticolumnOrderedIndex(depth int, index *inde if field.FD.Enum() != nil { key = "static_cast<" + helper.ParseCppType(field.FD) + ">(" + key + ")" } - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneCppMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) x.g.P(helper.Indent(depth+1), "}") } else { key := parentDataName + fieldName + suffix - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneCppMulticolumnOrderedIndex(depth, index, parentDataName, keys) } } @@ -263,7 +263,7 @@ func (x *Generator) genOrderedIndexSorter() { } func (x *Generator) GenCppOrderedIndexFinders() { - if !x.Generate() { + if !x.NeedGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go index d3eab80c..ad51515e 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go +++ b/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go @@ -22,7 +22,7 @@ func NewGenerator(g *protogen.GeneratedFile, message *protogen.Message) *Generat } } -func (x *Generator) Generate() bool { +func (x *Generator) NeedGenerate() bool { return options.NeedGenOrderedMap(x.message.Desc, options.LangCPP) } @@ -55,7 +55,7 @@ func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { } func (x *Generator) GenHppOrderedMapGetters() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P() @@ -97,7 +97,7 @@ func (x *Generator) genHppOrderedMapGetters(md protoreflect.MessageDescriptor, d } func (x *Generator) GenOrderedMapLoader() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.g.P(helper.Indent(1), "// OrderedMap init.") @@ -144,7 +144,7 @@ func (x *Generator) genOrderedMapLoader(md protoreflect.MessageDescriptor, depth } func (x *Generator) GenOrderedMapGetters() { - if !x.Generate() { + if !x.NeedGenerate() { return } x.genOrderedMapGetters(x.message.Desc, 1, nil) diff --git a/cmd/protoc-gen-go-tableau-loader/helper/helper.go b/cmd/protoc-gen-go-tableau-loader/helper/helper.go index 7dd23fcd..669cca52 100644 --- a/cmd/protoc-gen-go-tableau-loader/helper/helper.go +++ b/cmd/protoc-gen-go-tableau-loader/helper/helper.go @@ -98,9 +98,9 @@ func ParseMapKeyType(fd protoreflect.FieldDescriptor) string { } } -// ParseOrderedMapKeyType converts a FieldDescriptor to its treemap key type. +// ParseOrderedIndexKeyType converts a FieldDescriptor to its treemap key type. // fd must be an ordered type, or a message which can be converted to an ordered type. -func ParseOrderedMapKeyType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd protoreflect.FieldDescriptor) string { +func ParseOrderedIndexKeyType(gen *protogen.Plugin, g *protogen.GeneratedFile, fd protoreflect.FieldDescriptor) string { switch fd.Kind() { case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return "int32" @@ -261,8 +261,7 @@ func (keys MapKeys) AddMapKey(newKey MapKey) MapKeys { break } } - keys = append(keys, newKey) - return keys + return append(keys, newKey) } // GenGetParams generates function parameters, which are the names listed in the function's definition. diff --git a/cmd/protoc-gen-go-tableau-loader/index/index.go b/cmd/protoc-gen-go-tableau-loader/index/index.go index caf7930f..03278700 100644 --- a/cmd/protoc-gen-go-tableau-loader/index/index.go +++ b/cmd/protoc-gen-go-tableau-loader/index/index.go @@ -27,7 +27,7 @@ func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *i } } -func (x *Generator) generate() bool { +func (x *Generator) needGenerate() bool { return options.NeedGenIndex(x.message.Desc, options.LangGO) } @@ -36,7 +36,7 @@ func (x *Generator) messagerName() string { } func (x *Generator) mapType(index *index.LevelIndex) string { - return fmt.Sprintf("Index_%s_%sMap", x.messagerName(), index.Name()) + return fmt.Sprintf("%s_Index_%sMap", x.messagerName(), index.Name()) } func (x *Generator) mapKeyType(index *index.LevelIndex) string { @@ -46,7 +46,7 @@ func (x *Generator) mapKeyType(index *index.LevelIndex) string { return helper.ParseGoType(x.gen, x.g, field.FD) } else { // multi-column index - return fmt.Sprintf("Index_%s_%sKey", x.messagerName(), index.Name()) + return fmt.Sprintf("%s_Index_%sKey", x.messagerName(), index.Name()) } } @@ -59,9 +59,9 @@ func (x *Generator) indexContainerName(index *index.LevelIndex) string { } func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { - var keys []helper.MapKey + var keys helper.MapKeys for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ + keys = keys.AddMapKey(helper.MapKey{ Type: helper.ParseGoType(x.gen, x.g, field.FD), Name: helper.ParseIndexFieldNameAsFuncParam(x.gen, field.FD), FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(x.gen, field.FD), @@ -83,7 +83,7 @@ func (x *Generator) parseKeyFieldName(field *index.LevelField) string { } func (x *Generator) GenIndexTypeDef() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// Index types.") @@ -110,7 +110,7 @@ func (x *Generator) GenIndexTypeDef() { } func (x *Generator) GenIndexField() { - if !x.generate() { + if !x.needGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { @@ -121,7 +121,7 @@ func (x *Generator) GenIndexField() { } func (x *Generator) GenIndexLoader() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// Index init.") @@ -192,12 +192,12 @@ func (x *Generator) generateOneMulticolumnIndex(depth int, index *index.LevelInd if field.FD.IsList() { itemName := fmt.Sprintf("indexItem%d", cursor) x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") - keys = append(keys, helper.MapKey{Name: itemName}) + keys = keys.AddMapKey(helper.MapKey{Name: itemName}) x.generateOneMulticolumnIndex(depth+1, index, parentDataName, keys) x.g.P("}") } else { key := parentDataName + fieldName - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneMulticolumnIndex(depth, index, parentDataName, keys) } } @@ -227,7 +227,7 @@ func (x *Generator) genIndexSorter() { } func (x *Generator) GenIndexFinders() { - if !x.generate() { + if !x.needGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go index 56245c46..96f619e0 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go @@ -27,7 +27,7 @@ func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, descriptor *i } } -func (x *Generator) generate() bool { +func (x *Generator) needGenerate() bool { return options.NeedGenOrderedIndex(x.message.Desc, options.LangGO) } @@ -36,17 +36,17 @@ func (x *Generator) messagerName() string { } func (x *Generator) mapType(index *index.LevelIndex) string { - return fmt.Sprintf("OrderedIndex_%s_%sMap", x.messagerName(), index.Name()) + return fmt.Sprintf("%s_OrderedIndex_%sMap", x.messagerName(), index.Name()) } func (x *Generator) mapKeyType(index *index.LevelIndex) string { if len(index.ColFields) == 1 { // single-column index field := index.ColFields[0] // just take first field - return helper.ParseOrderedMapKeyType(x.gen, x.g, field.FD) + return helper.ParseOrderedIndexKeyType(x.gen, x.g, field.FD) } else { // multi-column index - return fmt.Sprintf("OrderedIndex_%s_%sKey", x.messagerName(), index.Name()) + return fmt.Sprintf("%s_OrderedIndex_%sKey", x.messagerName(), index.Name()) } } @@ -69,10 +69,10 @@ func (x *Generator) mapCtor(index *index.LevelIndex) string { } func (x *Generator) indexKeys(index *index.LevelIndex) helper.MapKeys { - var keys []helper.MapKey + var keys helper.MapKeys for _, field := range index.ColFields { - keys = append(keys, helper.MapKey{ - Type: helper.ParseOrderedMapKeyType(x.gen, x.g, field.FD), + keys = keys.AddMapKey(helper.MapKey{ + Type: helper.ParseOrderedIndexKeyType(x.gen, x.g, field.FD), Name: helper.ParseIndexFieldNameAsFuncParam(x.gen, field.FD), FieldName: helper.ParseIndexFieldNameAsKeyStructFieldName(x.gen, field.FD), }) @@ -100,7 +100,7 @@ func (x *Generator) parseKeyFieldNameAndSuffix(field *index.LevelField) (string, } func (x *Generator) GenOrderedIndexTypeDef() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// OrderedIndex types.") @@ -141,7 +141,7 @@ func (x *Generator) GenOrderedIndexTypeDef() { } func (x *Generator) GenOrderedIndexField() { - if !x.generate() { + if !x.needGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { @@ -152,7 +152,7 @@ func (x *Generator) GenOrderedIndexField() { } func (x *Generator) GenOrderedIndexLoader() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// OrderedIndex init.") @@ -227,12 +227,12 @@ func (x *Generator) generateOneMulticolumnOrderedIndex(depth int, index *index.L itemName := fmt.Sprintf("indexItem%d", cursor) x.g.P("for _, ", itemName, " := range ", parentDataName, fieldName, " {") key := itemName + suffix - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneMulticolumnOrderedIndex(depth+1, index, parentDataName, keys) x.g.P("}") } else { key := parentDataName + fieldName + suffix - keys = append(keys, helper.MapKey{Name: key}) + keys = keys.AddMapKey(helper.MapKey{Name: key}) x.generateOneMulticolumnOrderedIndex(depth, index, parentDataName, keys) } } @@ -263,7 +263,7 @@ func (x *Generator) genOrderedIndexSorter() { } func (x *Generator) GenOrderedIndexFinders() { - if !x.generate() { + if !x.needGenerate() { return } for levelMessage := x.descriptor.LevelMessage; levelMessage != nil; levelMessage = levelMessage.NextLevel { diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go index 84d6c370..6ad81ea3 100644 --- a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go +++ b/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go @@ -24,7 +24,7 @@ func NewGenerator(gen *protogen.Plugin, g *protogen.GeneratedFile, message *prot } } -func (x *Generator) generate() bool { +func (x *Generator) needGenerate() bool { return options.NeedGenOrderedMap(x.message.Desc, options.LangGO) } @@ -41,11 +41,11 @@ func (x *Generator) orderedMapPrefix(mapFd protoreflect.FieldDescriptor) string } func (x *Generator) mapType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("OrderedMap_%s_%sMap", x.messagerName(), x.orderedMapPrefix(mapFd)) + return fmt.Sprintf("%s_OrderedMap_%sMap", x.messagerName(), x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueType(mapFd protoreflect.FieldDescriptor) string { - return fmt.Sprintf("OrderedMap_%s_%sValue", x.messagerName(), x.orderedMapPrefix(mapFd)) + return fmt.Sprintf("%s_OrderedMap_%sValue", x.messagerName(), x.orderedMapPrefix(mapFd)) } func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { @@ -57,7 +57,7 @@ func (x *Generator) mapValueFieldType(fd protoreflect.FieldDescriptor) string { } func (x *Generator) GenOrderedMapTypeDef() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// OrderedMap types.") @@ -95,7 +95,7 @@ func (x *Generator) genOrderedMapTypeDef(md protoreflect.MessageDescriptor, dept } func (x *Generator) GenOrderedMapField() { - if !x.generate() { + if !x.needGenerate() { return } md := x.message.Desc @@ -109,7 +109,7 @@ func (x *Generator) GenOrderedMapField() { } func (x *Generator) GenOrderedMapLoader() { - if !x.generate() { + if !x.needGenerate() { return } x.g.P("// OrderedMap init.") @@ -171,7 +171,7 @@ func (x *Generator) genOrderedMapLoader(md protoreflect.MessageDescriptor, depth } func (x *Generator) GenOrderedMapGetters() { - if !x.generate() { + if !x.needGenerate() { return } x.genOrderedMapGetters(x.message.Desc, 1, nil) diff --git a/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go b/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go index 37c94ba3..b4a6bcf7 100644 --- a/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/hero_conf.pc.go @@ -21,7 +21,7 @@ import ( // Index types. // Index: Title -type Index_HeroConf_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr +type HeroConf_Index_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr // HeroConf is a wrapper around protobuf message: protoconf.HeroConf. // @@ -33,7 +33,7 @@ type Index_HeroConf_AttrMap = map[string][]*protoconf.HeroConf_Hero_Attr type HeroConf struct { UnimplementedMessager data, originalData *protoconf.HeroConf - indexAttrMap Index_HeroConf_AttrMap + indexAttrMap HeroConf_Index_AttrMap } // Name returns the HeroConf's message name. @@ -96,7 +96,7 @@ func (x *HeroConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *HeroConf) processAfterLoad() error { // Index init. - x.indexAttrMap = make(Index_HeroConf_AttrMap) + x.indexAttrMap = make(HeroConf_Index_AttrMap) for _, item1 := range x.data.GetHeroMap() { for _, item2 := range item1.GetAttrMap() { { @@ -139,7 +139,7 @@ func (x *HeroConf) Get2(name string, title string) (*protoconf.HeroConf_Hero_Att // FindAttrMap finds the index (Title) to value (protoconf.HeroConf_Hero_Attr) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *HeroConf) FindAttrMap() Index_HeroConf_AttrMap { +func (x *HeroConf) FindAttrMap() HeroConf_Index_AttrMap { return x.indexAttrMap } @@ -159,10 +159,10 @@ func (x *HeroConf) FindFirstAttr(title string) *protoconf.HeroConf_Hero_Attr { } // OrderedMap types. -type OrderedMap_HeroBaseConf_base_ItemMap = treemap.TreeMap[string, *base.Item] +type HeroBaseConf_OrderedMap_base_ItemMap = treemap.TreeMap[string, *base.Item] -type OrderedMap_HeroBaseConf_base_HeroValue = pair.Pair[*OrderedMap_HeroBaseConf_base_ItemMap, *base.Hero] -type OrderedMap_HeroBaseConf_base_HeroMap = treemap.TreeMap[string, *OrderedMap_HeroBaseConf_base_HeroValue] +type HeroBaseConf_OrderedMap_base_HeroValue = pair.Pair[*HeroBaseConf_OrderedMap_base_ItemMap, *base.Hero] +type HeroBaseConf_OrderedMap_base_HeroMap = treemap.TreeMap[string, *HeroBaseConf_OrderedMap_base_HeroValue] // HeroBaseConf is a wrapper around protobuf message: protoconf.HeroBaseConf. // @@ -174,7 +174,7 @@ type OrderedMap_HeroBaseConf_base_HeroMap = treemap.TreeMap[string, *OrderedMap_ type HeroBaseConf struct { UnimplementedMessager data, originalData *protoconf.HeroBaseConf - orderedMap *OrderedMap_HeroBaseConf_base_HeroMap + orderedMap *HeroBaseConf_OrderedMap_base_HeroMap } // Name returns the HeroBaseConf's message name. @@ -237,10 +237,10 @@ func (x *HeroBaseConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *HeroBaseConf) processAfterLoad() error { // OrderedMap init. - x.orderedMap = treemap.New[string, *OrderedMap_HeroBaseConf_base_HeroValue]() + x.orderedMap = treemap.New[string, *HeroBaseConf_OrderedMap_base_HeroValue]() for k1, v1 := range x.Data().GetHeroMap() { map1 := x.orderedMap - k1v := &OrderedMap_HeroBaseConf_base_HeroValue{ + k1v := &HeroBaseConf_OrderedMap_base_HeroValue{ First: treemap.New[string, *base.Item](), Second: v1, } @@ -280,13 +280,13 @@ func (x *HeroBaseConf) Get2(name string, id string) (*base.Item, error) { } // GetOrderedMap returns the 1-level ordered map. -func (x *HeroBaseConf) GetOrderedMap() *OrderedMap_HeroBaseConf_base_HeroMap { +func (x *HeroBaseConf) GetOrderedMap() *HeroBaseConf_OrderedMap_base_HeroMap { return x.orderedMap } // GetOrderedMap1 finds value in the 1-level ordered map. It will return // NotFound error if the key is not found. -func (x *HeroBaseConf) GetOrderedMap1(name string) (*OrderedMap_HeroBaseConf_base_ItemMap, error) { +func (x *HeroBaseConf) GetOrderedMap1(name string) (*HeroBaseConf_OrderedMap_base_ItemMap, error) { conf := x.orderedMap if val, ok := conf.Get(name); !ok { return nil, fmt.Errorf("name(%v) %w", name, ErrNotFound) diff --git a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go index cf139cc6..ffca0605 100644 --- a/test/go-tableau-loader/protoconf/loader/item_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/item_conf.pc.go @@ -19,67 +19,67 @@ import ( ) // OrderedMap types. -type OrderedMap_ItemConf_ItemMap = treemap.TreeMap[uint32, *protoconf.ItemConf_Item] +type ItemConf_OrderedMap_ItemMap = treemap.TreeMap[uint32, *protoconf.ItemConf_Item] // Index types. // Index: Type -type Index_ItemConf_ItemMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item // Index: Param@ItemInfo -type Index_ItemConf_ItemInfoMap = map[int32][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemInfoMap = map[int32][]*protoconf.ItemConf_Item // Index: Default@ItemDefaultInfo -type Index_ItemConf_ItemDefaultInfoMap = map[string][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemDefaultInfoMap = map[string][]*protoconf.ItemConf_Item // Index: ExtType@ItemExtInfo -type Index_ItemConf_ItemExtInfoMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemExtInfoMap = map[protoconf.FruitType][]*protoconf.ItemConf_Item // Index: (ID,Name)@AwardItem -type Index_ItemConf_AwardItemKey struct { +type ItemConf_Index_AwardItemKey struct { Id uint32 Name string } -type Index_ItemConf_AwardItemMap = map[Index_ItemConf_AwardItemKey][]*protoconf.ItemConf_Item +type ItemConf_Index_AwardItemMap = map[ItemConf_Index_AwardItemKey][]*protoconf.ItemConf_Item // Index: (ID,Type,Param,ExtType)@SpecialItem -type Index_ItemConf_SpecialItemKey struct { +type ItemConf_Index_SpecialItemKey struct { Id uint32 Type protoconf.FruitType Param int32 ExtType protoconf.FruitType } -type Index_ItemConf_SpecialItemMap = map[Index_ItemConf_SpecialItemKey][]*protoconf.ItemConf_Item +type ItemConf_Index_SpecialItemMap = map[ItemConf_Index_SpecialItemKey][]*protoconf.ItemConf_Item // Index: PathDir@ItemPathDir -type Index_ItemConf_ItemPathDirMap = map[string][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemPathDirMap = map[string][]*protoconf.ItemConf_Item // Index: PathName@ItemPathName -type Index_ItemConf_ItemPathNameMap = map[string][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemPathNameMap = map[string][]*protoconf.ItemConf_Item // Index: PathFriendID@ItemPathFriendID -type Index_ItemConf_ItemPathFriendIDMap = map[uint32][]*protoconf.ItemConf_Item +type ItemConf_Index_ItemPathFriendIDMap = map[uint32][]*protoconf.ItemConf_Item // Index: UseEffectType@UseEffectType -type Index_ItemConf_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf.ItemConf_Item +type ItemConf_Index_UseEffectTypeMap = map[protoconf.UseEffect_Type][]*protoconf.ItemConf_Item // OrderedIndex types. // OrderedIndex: ExtType@ExtType -type OrderedIndex_ItemConf_ExtTypeMap = treemap.TreeMap[protoconf.FruitType, []*protoconf.ItemConf_Item] +type ItemConf_OrderedIndex_ExtTypeMap = treemap.TreeMap[protoconf.FruitType, []*protoconf.ItemConf_Item] // OrderedIndex: (Param,ExtType)@ParamExtType -type OrderedIndex_ItemConf_ParamExtTypeKey struct { +type ItemConf_OrderedIndex_ParamExtTypeKey struct { Param int32 ExtType protoconf.FruitType } -func (x OrderedIndex_ItemConf_ParamExtTypeKey) Less(other OrderedIndex_ItemConf_ParamExtTypeKey) bool { +func (x ItemConf_OrderedIndex_ParamExtTypeKey) Less(other ItemConf_OrderedIndex_ParamExtTypeKey) bool { if x.Param != other.Param { return x.Param < other.Param } return x.ExtType < other.ExtType } -type OrderedIndex_ItemConf_ParamExtTypeMap = treemap.TreeMap[OrderedIndex_ItemConf_ParamExtTypeKey, []*protoconf.ItemConf_Item] +type ItemConf_OrderedIndex_ParamExtTypeMap = treemap.TreeMap[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item] // ItemConf is a wrapper around protobuf message: protoconf.ItemConf. // @@ -91,19 +91,19 @@ type OrderedIndex_ItemConf_ParamExtTypeMap = treemap.TreeMap[OrderedIndex_ItemCo type ItemConf struct { UnimplementedMessager data, originalData *protoconf.ItemConf - orderedMap *OrderedMap_ItemConf_ItemMap - indexItemMap Index_ItemConf_ItemMap - indexItemInfoMap Index_ItemConf_ItemInfoMap - indexItemDefaultInfoMap Index_ItemConf_ItemDefaultInfoMap - indexItemExtInfoMap Index_ItemConf_ItemExtInfoMap - indexAwardItemMap Index_ItemConf_AwardItemMap - indexSpecialItemMap Index_ItemConf_SpecialItemMap - indexItemPathDirMap Index_ItemConf_ItemPathDirMap - indexItemPathNameMap Index_ItemConf_ItemPathNameMap - indexItemPathFriendIdMap Index_ItemConf_ItemPathFriendIDMap - indexUseEffectTypeMap Index_ItemConf_UseEffectTypeMap - orderedIndexExtTypeMap *OrderedIndex_ItemConf_ExtTypeMap - orderedIndexParamExtTypeMap *OrderedIndex_ItemConf_ParamExtTypeMap + orderedMap *ItemConf_OrderedMap_ItemMap + indexItemMap ItemConf_Index_ItemMap + indexItemInfoMap ItemConf_Index_ItemInfoMap + indexItemDefaultInfoMap ItemConf_Index_ItemDefaultInfoMap + indexItemExtInfoMap ItemConf_Index_ItemExtInfoMap + indexAwardItemMap ItemConf_Index_AwardItemMap + indexSpecialItemMap ItemConf_Index_SpecialItemMap + indexItemPathDirMap ItemConf_Index_ItemPathDirMap + indexItemPathNameMap ItemConf_Index_ItemPathNameMap + indexItemPathFriendIdMap ItemConf_Index_ItemPathFriendIDMap + indexUseEffectTypeMap ItemConf_Index_UseEffectTypeMap + orderedIndexExtTypeMap *ItemConf_OrderedIndex_ExtTypeMap + orderedIndexParamExtTypeMap *ItemConf_OrderedIndex_ParamExtTypeMap } // Name returns the ItemConf's message name. @@ -172,16 +172,16 @@ func (x *ItemConf) processAfterLoad() error { map1.Put(k1, v1) } // Index init. - x.indexItemMap = make(Index_ItemConf_ItemMap) - x.indexItemInfoMap = make(Index_ItemConf_ItemInfoMap) - x.indexItemDefaultInfoMap = make(Index_ItemConf_ItemDefaultInfoMap) - x.indexItemExtInfoMap = make(Index_ItemConf_ItemExtInfoMap) - x.indexAwardItemMap = make(Index_ItemConf_AwardItemMap) - x.indexSpecialItemMap = make(Index_ItemConf_SpecialItemMap) - x.indexItemPathDirMap = make(Index_ItemConf_ItemPathDirMap) - x.indexItemPathNameMap = make(Index_ItemConf_ItemPathNameMap) - x.indexItemPathFriendIdMap = make(Index_ItemConf_ItemPathFriendIDMap) - x.indexUseEffectTypeMap = make(Index_ItemConf_UseEffectTypeMap) + x.indexItemMap = make(ItemConf_Index_ItemMap) + x.indexItemInfoMap = make(ItemConf_Index_ItemInfoMap) + x.indexItemDefaultInfoMap = make(ItemConf_Index_ItemDefaultInfoMap) + x.indexItemExtInfoMap = make(ItemConf_Index_ItemExtInfoMap) + x.indexAwardItemMap = make(ItemConf_Index_AwardItemMap) + x.indexSpecialItemMap = make(ItemConf_Index_SpecialItemMap) + x.indexItemPathDirMap = make(ItemConf_Index_ItemPathDirMap) + x.indexItemPathNameMap = make(ItemConf_Index_ItemPathNameMap) + x.indexItemPathFriendIdMap = make(ItemConf_Index_ItemPathFriendIDMap) + x.indexUseEffectTypeMap = make(ItemConf_Index_UseEffectTypeMap) for _, item1 := range x.data.GetItemMap() { { // Index: Type @@ -209,14 +209,14 @@ func (x *ItemConf) processAfterLoad() error { } { // Index: (ID,Name)@AwardItem - key := Index_ItemConf_AwardItemKey{item1.GetId(), item1.GetName()} + key := ItemConf_Index_AwardItemKey{item1.GetId(), item1.GetName()} x.indexAwardItemMap[key] = append(x.indexAwardItemMap[key], item1) } { // Index: (ID,Type,Param,ExtType)@SpecialItem for _, indexItem2 := range item1.GetParamList() { for _, indexItem3 := range item1.GetExtTypeList() { - key := Index_ItemConf_SpecialItemKey{item1.GetId(), item1.GetType(), indexItem2, indexItem3} + key := ItemConf_Index_SpecialItemKey{item1.GetId(), item1.GetType(), indexItem2, indexItem3} x.indexSpecialItemMap[key] = append(x.indexSpecialItemMap[key], item1) } } @@ -261,7 +261,7 @@ func (x *ItemConf) processAfterLoad() error { } // OrderedIndex init. x.orderedIndexExtTypeMap = treemap.New[protoconf.FruitType, []*protoconf.ItemConf_Item]() - x.orderedIndexParamExtTypeMap = treemap.New2[OrderedIndex_ItemConf_ParamExtTypeKey, []*protoconf.ItemConf_Item]() + x.orderedIndexParamExtTypeMap = treemap.New2[ItemConf_OrderedIndex_ParamExtTypeKey, []*protoconf.ItemConf_Item]() for _, item1 := range x.data.GetItemMap() { { // OrderedIndex: ExtType@ExtType @@ -275,7 +275,7 @@ func (x *ItemConf) processAfterLoad() error { // OrderedIndex: (Param,ExtType)@ParamExtType for _, indexItem0 := range item1.GetParamList() { for _, indexItem1 := range item1.GetExtTypeList() { - key := OrderedIndex_ItemConf_ParamExtTypeKey{indexItem0, indexItem1} + key := ItemConf_OrderedIndex_ParamExtTypeKey{indexItem0, indexItem1} value, _ := x.orderedIndexParamExtTypeMap.Get(key) x.orderedIndexParamExtTypeMap.Put(key, append(value, item1)) } @@ -283,7 +283,7 @@ func (x *ItemConf) processAfterLoad() error { } } // OrderedIndex(sort): (Param,ExtType)@ParamExtType - x.orderedIndexParamExtTypeMap.Range(func(key OrderedIndex_ItemConf_ParamExtTypeKey, item []*protoconf.ItemConf_Item) bool { + x.orderedIndexParamExtTypeMap.Range(func(key ItemConf_OrderedIndex_ParamExtTypeKey, item []*protoconf.ItemConf_Item) bool { sort.Slice(item, func(i, j int) bool { return item[i].GetId() < item[j].GetId() }) @@ -304,7 +304,7 @@ func (x *ItemConf) Get1(id uint32) (*protoconf.ItemConf_Item, error) { } // GetOrderedMap returns the 1-level ordered map. -func (x *ItemConf) GetOrderedMap() *OrderedMap_ItemConf_ItemMap { +func (x *ItemConf) GetOrderedMap() *ItemConf_OrderedMap_ItemMap { return x.orderedMap } @@ -312,7 +312,7 @@ func (x *ItemConf) GetOrderedMap() *OrderedMap_ItemConf_ItemMap { // FindItemMap finds the index (Type) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemMap() Index_ItemConf_ItemMap { +func (x *ItemConf) FindItemMap() ItemConf_Index_ItemMap { return x.indexItemMap } @@ -335,7 +335,7 @@ func (x *ItemConf) FindFirstItem(type_ protoconf.FruitType) *protoconf.ItemConf_ // FindItemInfoMap finds the index (Param@ItemInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemInfoMap() Index_ItemConf_ItemInfoMap { +func (x *ItemConf) FindItemInfoMap() ItemConf_Index_ItemInfoMap { return x.indexItemInfoMap } @@ -358,7 +358,7 @@ func (x *ItemConf) FindFirstItemInfo(param int32) *protoconf.ItemConf_Item { // FindItemDefaultInfoMap finds the index (Default@ItemDefaultInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemDefaultInfoMap() Index_ItemConf_ItemDefaultInfoMap { +func (x *ItemConf) FindItemDefaultInfoMap() ItemConf_Index_ItemDefaultInfoMap { return x.indexItemDefaultInfoMap } @@ -381,7 +381,7 @@ func (x *ItemConf) FindFirstItemDefaultInfo(default_ string) *protoconf.ItemConf // FindItemExtInfoMap finds the index (ExtType@ItemExtInfo) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemExtInfoMap() Index_ItemConf_ItemExtInfoMap { +func (x *ItemConf) FindItemExtInfoMap() ItemConf_Index_ItemExtInfoMap { return x.indexItemExtInfoMap } @@ -404,13 +404,13 @@ func (x *ItemConf) FindFirstItemExtInfo(extType protoconf.FruitType) *protoconf. // FindAwardItemMap finds the index ((ID,Name)@AwardItem) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindAwardItemMap() Index_ItemConf_AwardItemMap { +func (x *ItemConf) FindAwardItemMap() ItemConf_Index_AwardItemMap { return x.indexAwardItemMap } // FindAwardItem finds a slice of all values of the given key. func (x *ItemConf) FindAwardItem(id uint32, name string) []*protoconf.ItemConf_Item { - return x.indexAwardItemMap[Index_ItemConf_AwardItemKey{id, name}] + return x.indexAwardItemMap[ItemConf_Index_AwardItemKey{id, name}] } // FindFirstAwardItem finds the first value of the given key, @@ -427,13 +427,13 @@ func (x *ItemConf) FindFirstAwardItem(id uint32, name string) *protoconf.ItemCon // FindSpecialItemMap finds the index ((ID,Type,Param,ExtType)@SpecialItem) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindSpecialItemMap() Index_ItemConf_SpecialItemMap { +func (x *ItemConf) FindSpecialItemMap() ItemConf_Index_SpecialItemMap { return x.indexSpecialItemMap } // FindSpecialItem finds a slice of all values of the given key. func (x *ItemConf) FindSpecialItem(id uint32, type_ protoconf.FruitType, param int32, extType protoconf.FruitType) []*protoconf.ItemConf_Item { - return x.indexSpecialItemMap[Index_ItemConf_SpecialItemKey{id, type_, param, extType}] + return x.indexSpecialItemMap[ItemConf_Index_SpecialItemKey{id, type_, param, extType}] } // FindFirstSpecialItem finds the first value of the given key, @@ -450,7 +450,7 @@ func (x *ItemConf) FindFirstSpecialItem(id uint32, type_ protoconf.FruitType, pa // FindItemPathDirMap finds the index (PathDir@ItemPathDir) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathDirMap() Index_ItemConf_ItemPathDirMap { +func (x *ItemConf) FindItemPathDirMap() ItemConf_Index_ItemPathDirMap { return x.indexItemPathDirMap } @@ -473,7 +473,7 @@ func (x *ItemConf) FindFirstItemPathDir(dir string) *protoconf.ItemConf_Item { // FindItemPathNameMap finds the index (PathName@ItemPathName) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathNameMap() Index_ItemConf_ItemPathNameMap { +func (x *ItemConf) FindItemPathNameMap() ItemConf_Index_ItemPathNameMap { return x.indexItemPathNameMap } @@ -496,7 +496,7 @@ func (x *ItemConf) FindFirstItemPathName(name string) *protoconf.ItemConf_Item { // FindItemPathFriendIDMap finds the index (PathFriendID@ItemPathFriendID) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindItemPathFriendIDMap() Index_ItemConf_ItemPathFriendIDMap { +func (x *ItemConf) FindItemPathFriendIDMap() ItemConf_Index_ItemPathFriendIDMap { return x.indexItemPathFriendIdMap } @@ -519,7 +519,7 @@ func (x *ItemConf) FindFirstItemPathFriendID(id uint32) *protoconf.ItemConf_Item // FindUseEffectTypeMap finds the index (UseEffectType@UseEffectType) to value (protoconf.ItemConf_Item) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindUseEffectTypeMap() Index_ItemConf_UseEffectTypeMap { +func (x *ItemConf) FindUseEffectTypeMap() ItemConf_Index_UseEffectTypeMap { return x.indexUseEffectTypeMap } @@ -542,7 +542,7 @@ func (x *ItemConf) FindFirstUseEffectType(type_ protoconf.UseEffect_Type) *proto // FindExtTypeMap finds the ordered index (ExtType@ExtType) to value (protoconf.ItemConf_Item) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindExtTypeMap() *OrderedIndex_ItemConf_ExtTypeMap { +func (x *ItemConf) FindExtTypeMap() *ItemConf_OrderedIndex_ExtTypeMap { return x.orderedIndexExtTypeMap } @@ -566,13 +566,13 @@ func (x *ItemConf) FindFirstExtType(extType protoconf.FruitType) *protoconf.Item // FindParamExtTypeMap finds the ordered index ((Param,ExtType)@ParamExtType) to value (protoconf.ItemConf_Item) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *ItemConf) FindParamExtTypeMap() *OrderedIndex_ItemConf_ParamExtTypeMap { +func (x *ItemConf) FindParamExtTypeMap() *ItemConf_OrderedIndex_ParamExtTypeMap { return x.orderedIndexParamExtTypeMap } // FindParamExtType finds a slice of all values of the given key. func (x *ItemConf) FindParamExtType(param int32, extType protoconf.FruitType) []*protoconf.ItemConf_Item { - val, _ := x.orderedIndexParamExtTypeMap.Get(OrderedIndex_ItemConf_ParamExtTypeKey{param, extType}) + val, _ := x.orderedIndexParamExtTypeMap.Get(ItemConf_OrderedIndex_ParamExtTypeKey{param, extType}) return val } diff --git a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go index c2aa15c6..67385585 100644 --- a/test/go-tableau-loader/protoconf/loader/test_conf.pc.go +++ b/test/go-tableau-loader/protoconf/loader/test_conf.pc.go @@ -20,29 +20,29 @@ import ( ) // OrderedMap types. -type OrderedMap_ActivityConf_int32Map = treemap.TreeMap[uint32, int32] +type ActivityConf_OrderedMap_int32Map = treemap.TreeMap[uint32, int32] -type OrderedMap_ActivityConf_protoconf_SectionValue = pair.Pair[*OrderedMap_ActivityConf_int32Map, *protoconf.Section] -type OrderedMap_ActivityConf_protoconf_SectionMap = treemap.TreeMap[uint32, *OrderedMap_ActivityConf_protoconf_SectionValue] +type ActivityConf_OrderedMap_protoconf_SectionValue = pair.Pair[*ActivityConf_OrderedMap_int32Map, *protoconf.Section] +type ActivityConf_OrderedMap_protoconf_SectionMap = treemap.TreeMap[uint32, *ActivityConf_OrderedMap_protoconf_SectionValue] -type OrderedMap_ActivityConf_Activity_ChapterValue = pair.Pair[*OrderedMap_ActivityConf_protoconf_SectionMap, *protoconf.ActivityConf_Activity_Chapter] -type OrderedMap_ActivityConf_Activity_ChapterMap = treemap.TreeMap[uint32, *OrderedMap_ActivityConf_Activity_ChapterValue] +type ActivityConf_OrderedMap_Activity_ChapterValue = pair.Pair[*ActivityConf_OrderedMap_protoconf_SectionMap, *protoconf.ActivityConf_Activity_Chapter] +type ActivityConf_OrderedMap_Activity_ChapterMap = treemap.TreeMap[uint32, *ActivityConf_OrderedMap_Activity_ChapterValue] -type OrderedMap_ActivityConf_ActivityValue = pair.Pair[*OrderedMap_ActivityConf_Activity_ChapterMap, *protoconf.ActivityConf_Activity] -type OrderedMap_ActivityConf_ActivityMap = treemap.TreeMap[uint64, *OrderedMap_ActivityConf_ActivityValue] +type ActivityConf_OrderedMap_ActivityValue = pair.Pair[*ActivityConf_OrderedMap_Activity_ChapterMap, *protoconf.ActivityConf_Activity] +type ActivityConf_OrderedMap_ActivityMap = treemap.TreeMap[uint64, *ActivityConf_OrderedMap_ActivityValue] // Index types. // Index: ActivityName -type Index_ActivityConf_ActivityMap = map[string][]*protoconf.ActivityConf_Activity +type ActivityConf_Index_ActivityMap = map[string][]*protoconf.ActivityConf_Activity // Index: ChapterID -type Index_ActivityConf_ChapterMap = map[uint32][]*protoconf.ActivityConf_Activity_Chapter +type ActivityConf_Index_ChapterMap = map[uint32][]*protoconf.ActivityConf_Activity_Chapter // Index: ChapterName@NamedChapter -type Index_ActivityConf_NamedChapterMap = map[string][]*protoconf.ActivityConf_Activity_Chapter +type ActivityConf_Index_NamedChapterMap = map[string][]*protoconf.ActivityConf_Activity_Chapter // Index: SectionItemID@Award -type Index_ActivityConf_AwardMap = map[uint32][]*protoconf.Section_SectionItem +type ActivityConf_Index_AwardMap = map[uint32][]*protoconf.Section_SectionItem // ActivityConf is a wrapper around protobuf message: protoconf.ActivityConf. // @@ -54,11 +54,11 @@ type Index_ActivityConf_AwardMap = map[uint32][]*protoconf.Section_SectionItem type ActivityConf struct { UnimplementedMessager data, originalData *protoconf.ActivityConf - orderedMap *OrderedMap_ActivityConf_ActivityMap - indexActivityMap Index_ActivityConf_ActivityMap - indexChapterMap Index_ActivityConf_ChapterMap - indexNamedChapterMap Index_ActivityConf_NamedChapterMap - indexAwardMap Index_ActivityConf_AwardMap + orderedMap *ActivityConf_OrderedMap_ActivityMap + indexActivityMap ActivityConf_Index_ActivityMap + indexChapterMap ActivityConf_Index_ChapterMap + indexNamedChapterMap ActivityConf_Index_NamedChapterMap + indexAwardMap ActivityConf_Index_AwardMap } // Name returns the ActivityConf's message name. @@ -121,24 +121,24 @@ func (x *ActivityConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *ActivityConf) processAfterLoad() error { // OrderedMap init. - x.orderedMap = treemap.New[uint64, *OrderedMap_ActivityConf_ActivityValue]() + x.orderedMap = treemap.New[uint64, *ActivityConf_OrderedMap_ActivityValue]() for k1, v1 := range x.Data().GetActivityMap() { map1 := x.orderedMap - k1v := &OrderedMap_ActivityConf_ActivityValue{ - First: treemap.New[uint32, *OrderedMap_ActivityConf_Activity_ChapterValue](), + k1v := &ActivityConf_OrderedMap_ActivityValue{ + First: treemap.New[uint32, *ActivityConf_OrderedMap_Activity_ChapterValue](), Second: v1, } map1.Put(k1, k1v) for k2, v2 := range v1.GetChapterMap() { map2 := k1v.First - k2v := &OrderedMap_ActivityConf_Activity_ChapterValue{ - First: treemap.New[uint32, *OrderedMap_ActivityConf_protoconf_SectionValue](), + k2v := &ActivityConf_OrderedMap_Activity_ChapterValue{ + First: treemap.New[uint32, *ActivityConf_OrderedMap_protoconf_SectionValue](), Second: v2, } map2.Put(k2, k2v) for k3, v3 := range v2.GetSectionMap() { map3 := k2v.First - k3v := &OrderedMap_ActivityConf_protoconf_SectionValue{ + k3v := &ActivityConf_OrderedMap_protoconf_SectionValue{ First: treemap.New[uint32, int32](), Second: v3, } @@ -151,10 +151,10 @@ func (x *ActivityConf) processAfterLoad() error { } } // Index init. - x.indexActivityMap = make(Index_ActivityConf_ActivityMap) - x.indexChapterMap = make(Index_ActivityConf_ChapterMap) - x.indexNamedChapterMap = make(Index_ActivityConf_NamedChapterMap) - x.indexAwardMap = make(Index_ActivityConf_AwardMap) + x.indexActivityMap = make(ActivityConf_Index_ActivityMap) + x.indexChapterMap = make(ActivityConf_Index_ChapterMap) + x.indexNamedChapterMap = make(ActivityConf_Index_NamedChapterMap) + x.indexAwardMap = make(ActivityConf_Index_AwardMap) for _, item1 := range x.data.GetActivityMap() { { // Index: ActivityName @@ -249,13 +249,13 @@ func (x *ActivityConf) Get4(activityId uint64, chapterId uint32, sectionId uint3 } // GetOrderedMap returns the 1-level ordered map. -func (x *ActivityConf) GetOrderedMap() *OrderedMap_ActivityConf_ActivityMap { +func (x *ActivityConf) GetOrderedMap() *ActivityConf_OrderedMap_ActivityMap { return x.orderedMap } // GetOrderedMap1 finds value in the 1-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*OrderedMap_ActivityConf_Activity_ChapterMap, error) { +func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*ActivityConf_OrderedMap_Activity_ChapterMap, error) { conf := x.orderedMap if val, ok := conf.Get(activityId); !ok { return nil, fmt.Errorf("activityId(%v) %w", activityId, ErrNotFound) @@ -266,7 +266,7 @@ func (x *ActivityConf) GetOrderedMap1(activityId uint64) (*OrderedMap_ActivityCo // GetOrderedMap2 finds value in the 2-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*OrderedMap_ActivityConf_protoconf_SectionMap, error) { +func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*ActivityConf_OrderedMap_protoconf_SectionMap, error) { conf, err := x.GetOrderedMap1(activityId) if err != nil { return nil, err @@ -280,7 +280,7 @@ func (x *ActivityConf) GetOrderedMap2(activityId uint64, chapterId uint32) (*Ord // GetOrderedMap3 finds value in the 3-level ordered map. It will return // NotFound error if the key is not found. -func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, sectionId uint32) (*OrderedMap_ActivityConf_int32Map, error) { +func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, sectionId uint32) (*ActivityConf_OrderedMap_int32Map, error) { conf, err := x.GetOrderedMap2(activityId, chapterId) if err != nil { return nil, err @@ -296,7 +296,7 @@ func (x *ActivityConf) GetOrderedMap3(activityId uint64, chapterId uint32, secti // FindActivityMap finds the index (ActivityName) to value (protoconf.ActivityConf_Activity) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindActivityMap() Index_ActivityConf_ActivityMap { +func (x *ActivityConf) FindActivityMap() ActivityConf_Index_ActivityMap { return x.indexActivityMap } @@ -319,7 +319,7 @@ func (x *ActivityConf) FindFirstActivity(activityName string) *protoconf.Activit // FindChapterMap finds the index (ChapterID) to value (protoconf.ActivityConf_Activity_Chapter) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindChapterMap() Index_ActivityConf_ChapterMap { +func (x *ActivityConf) FindChapterMap() ActivityConf_Index_ChapterMap { return x.indexChapterMap } @@ -342,7 +342,7 @@ func (x *ActivityConf) FindFirstChapter(chapterId uint32) *protoconf.ActivityCon // FindNamedChapterMap finds the index (ChapterName@NamedChapter) to value (protoconf.ActivityConf_Activity_Chapter) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindNamedChapterMap() Index_ActivityConf_NamedChapterMap { +func (x *ActivityConf) FindNamedChapterMap() ActivityConf_Index_NamedChapterMap { return x.indexNamedChapterMap } @@ -365,7 +365,7 @@ func (x *ActivityConf) FindFirstNamedChapter(chapterName string) *protoconf.Acti // FindAwardMap finds the index (SectionItemID@Award) to value (protoconf.Section_SectionItem) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *ActivityConf) FindAwardMap() Index_ActivityConf_AwardMap { +func (x *ActivityConf) FindAwardMap() ActivityConf_Index_AwardMap { return x.indexAwardMap } @@ -561,32 +561,32 @@ func (x *ThemeConf) Get2(name string, param string) (string, error) { // Index types. // Index: ActivityID -type Index_TaskConf_TaskMap = map[int64][]*protoconf.TaskConf_Task +type TaskConf_Index_TaskMap = map[int64][]*protoconf.TaskConf_Task // OrderedIndex types. // OrderedIndex: Goal@OrderedTask -type OrderedIndex_TaskConf_OrderedTaskMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type TaskConf_OrderedIndex_OrderedTaskMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: Expiry@TaskExpiry -type OrderedIndex_TaskConf_TaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type TaskConf_OrderedIndex_TaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: Expiry@SortedTaskExpiry -type OrderedIndex_TaskConf_SortedTaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] +type TaskConf_OrderedIndex_SortedTaskExpiryMap = treemap.TreeMap[int64, []*protoconf.TaskConf_Task] // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry -type OrderedIndex_TaskConf_ActivityExpiryKey struct { +type TaskConf_OrderedIndex_ActivityExpiryKey struct { Expiry int64 ActivityId int64 } -func (x OrderedIndex_TaskConf_ActivityExpiryKey) Less(other OrderedIndex_TaskConf_ActivityExpiryKey) bool { +func (x TaskConf_OrderedIndex_ActivityExpiryKey) Less(other TaskConf_OrderedIndex_ActivityExpiryKey) bool { if x.Expiry != other.Expiry { return x.Expiry < other.Expiry } return x.ActivityId < other.ActivityId } -type OrderedIndex_TaskConf_ActivityExpiryMap = treemap.TreeMap[OrderedIndex_TaskConf_ActivityExpiryKey, []*protoconf.TaskConf_Task] +type TaskConf_OrderedIndex_ActivityExpiryMap = treemap.TreeMap[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task] // TaskConf is a wrapper around protobuf message: protoconf.TaskConf. // @@ -598,11 +598,11 @@ type OrderedIndex_TaskConf_ActivityExpiryMap = treemap.TreeMap[OrderedIndex_Task type TaskConf struct { UnimplementedMessager data, originalData *protoconf.TaskConf - indexTaskMap Index_TaskConf_TaskMap - orderedIndexOrderedTaskMap *OrderedIndex_TaskConf_OrderedTaskMap - orderedIndexTaskExpiryMap *OrderedIndex_TaskConf_TaskExpiryMap - orderedIndexSortedTaskExpiryMap *OrderedIndex_TaskConf_SortedTaskExpiryMap - orderedIndexActivityExpiryMap *OrderedIndex_TaskConf_ActivityExpiryMap + indexTaskMap TaskConf_Index_TaskMap + orderedIndexOrderedTaskMap *TaskConf_OrderedIndex_OrderedTaskMap + orderedIndexTaskExpiryMap *TaskConf_OrderedIndex_TaskExpiryMap + orderedIndexSortedTaskExpiryMap *TaskConf_OrderedIndex_SortedTaskExpiryMap + orderedIndexActivityExpiryMap *TaskConf_OrderedIndex_ActivityExpiryMap } // Name returns the TaskConf's message name. @@ -665,7 +665,7 @@ func (x *TaskConf) originalMessage() proto.Message { // processAfterLoad runs after this messager is loaded. func (x *TaskConf) processAfterLoad() error { // Index init. - x.indexTaskMap = make(Index_TaskConf_TaskMap) + x.indexTaskMap = make(TaskConf_Index_TaskMap) for _, item1 := range x.data.GetTaskMap() { { // Index: ActivityID @@ -686,7 +686,7 @@ func (x *TaskConf) processAfterLoad() error { x.orderedIndexOrderedTaskMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() x.orderedIndexSortedTaskExpiryMap = treemap.New[int64, []*protoconf.TaskConf_Task]() - x.orderedIndexActivityExpiryMap = treemap.New2[OrderedIndex_TaskConf_ActivityExpiryKey, []*protoconf.TaskConf_Task]() + x.orderedIndexActivityExpiryMap = treemap.New2[TaskConf_OrderedIndex_ActivityExpiryKey, []*protoconf.TaskConf_Task]() for _, item1 := range x.data.GetTaskMap() { { // OrderedIndex: Goal@OrderedTask @@ -708,7 +708,7 @@ func (x *TaskConf) processAfterLoad() error { } { // OrderedIndex: (Expiry,ActivityID)@ActivityExpiry - key := OrderedIndex_TaskConf_ActivityExpiryKey{item1.GetExpiry().GetSeconds(), item1.GetActivityId()} + key := TaskConf_OrderedIndex_ActivityExpiryKey{item1.GetExpiry().GetSeconds(), item1.GetActivityId()} value, _ := x.orderedIndexActivityExpiryMap.Get(key) x.orderedIndexActivityExpiryMap.Put(key, append(value, item1)) } @@ -748,7 +748,7 @@ func (x *TaskConf) Get1(id int64) (*protoconf.TaskConf_Task, error) { // FindTaskMap finds the index (ActivityID) to value (protoconf.TaskConf_Task) map. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindTaskMap() Index_TaskConf_TaskMap { +func (x *TaskConf) FindTaskMap() TaskConf_Index_TaskMap { return x.indexTaskMap } @@ -771,7 +771,7 @@ func (x *TaskConf) FindFirstTask(activityId int64) *protoconf.TaskConf_Task { // FindOrderedTaskMap finds the ordered index (Goal@OrderedTask) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindOrderedTaskMap() *OrderedIndex_TaskConf_OrderedTaskMap { +func (x *TaskConf) FindOrderedTaskMap() *TaskConf_OrderedIndex_OrderedTaskMap { return x.orderedIndexOrderedTaskMap } @@ -795,7 +795,7 @@ func (x *TaskConf) FindFirstOrderedTask(goal int64) *protoconf.TaskConf_Task { // FindTaskExpiryMap finds the ordered index (Expiry@TaskExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindTaskExpiryMap() *OrderedIndex_TaskConf_TaskExpiryMap { +func (x *TaskConf) FindTaskExpiryMap() *TaskConf_OrderedIndex_TaskExpiryMap { return x.orderedIndexTaskExpiryMap } @@ -819,7 +819,7 @@ func (x *TaskConf) FindFirstTaskExpiry(expiry int64) *protoconf.TaskConf_Task { // FindSortedTaskExpiryMap finds the ordered index (Expiry@SortedTaskExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindSortedTaskExpiryMap() *OrderedIndex_TaskConf_SortedTaskExpiryMap { +func (x *TaskConf) FindSortedTaskExpiryMap() *TaskConf_OrderedIndex_SortedTaskExpiryMap { return x.orderedIndexSortedTaskExpiryMap } @@ -843,13 +843,13 @@ func (x *TaskConf) FindFirstSortedTaskExpiry(expiry int64) *protoconf.TaskConf_T // FindActivityExpiryMap finds the ordered index ((Expiry,ActivityID)@ActivityExpiry) to value (protoconf.TaskConf_Task) treemap. // One key may correspond to multiple values, which are contained by a slice. -func (x *TaskConf) FindActivityExpiryMap() *OrderedIndex_TaskConf_ActivityExpiryMap { +func (x *TaskConf) FindActivityExpiryMap() *TaskConf_OrderedIndex_ActivityExpiryMap { return x.orderedIndexActivityExpiryMap } // FindActivityExpiry finds a slice of all values of the given key. func (x *TaskConf) FindActivityExpiry(expiry int64, activityId int64) []*protoconf.TaskConf_Task { - val, _ := x.orderedIndexActivityExpiryMap.Get(OrderedIndex_TaskConf_ActivityExpiryKey{expiry, activityId}) + val, _ := x.orderedIndexActivityExpiryMap.Get(TaskConf_OrderedIndex_ActivityExpiryKey{expiry, activityId}) return val } From 831a2b605c1b1952280f341905d019d5d88fa238 Mon Sep 17 00:00:00 2001 From: Kybxd <627940450@qq.com> Date: Mon, 17 Nov 2025 22:25:55 +0800 Subject: [PATCH 8/8] feat: package rename --- cmd/protoc-gen-cpp-tableau-loader/messager.go | 4 ++-- .../{ordered_index => orderedindex}/ordered_index.go | 0 .../{ordered_map => orderedmap}/ordered_map.go | 0 cmd/protoc-gen-go-tableau-loader/messager.go | 4 ++-- .../{ordered_index => orderedindex}/ordered_index.go | 0 .../{ordered_map => orderedmap}/ordered_map.go | 0 6 files changed, 4 insertions(+), 4 deletions(-) rename cmd/protoc-gen-cpp-tableau-loader/{ordered_index => orderedindex}/ordered_index.go (100%) rename cmd/protoc-gen-cpp-tableau-loader/{ordered_map => orderedmap}/ordered_map.go (100%) rename cmd/protoc-gen-go-tableau-loader/{ordered_index => orderedindex}/ordered_index.go (100%) rename cmd/protoc-gen-go-tableau-loader/{ordered_map => orderedmap}/ordered_map.go (100%) diff --git a/cmd/protoc-gen-cpp-tableau-loader/messager.go b/cmd/protoc-gen-cpp-tableau-loader/messager.go index fb35ca1f..a9f6f0a3 100644 --- a/cmd/protoc-gen-cpp-tableau-loader/messager.go +++ b/cmd/protoc-gen-cpp-tableau-loader/messager.go @@ -5,8 +5,8 @@ import ( "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/helper" idx "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/index" - orderedindex "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/ordered_index" - orderedmap "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/ordered_map" + "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/orderedindex" + "github.com/tableauio/loader/cmd/protoc-gen-cpp-tableau-loader/orderedmap" "github.com/tableauio/loader/internal/extensions" "github.com/tableauio/loader/internal/index" "github.com/tableauio/tableau/proto/tableaupb" diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-cpp-tableau-loader/orderedindex/ordered_index.go similarity index 100% rename from cmd/protoc-gen-cpp-tableau-loader/ordered_index/ordered_index.go rename to cmd/protoc-gen-cpp-tableau-loader/orderedindex/ordered_index.go diff --git a/cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-cpp-tableau-loader/orderedmap/ordered_map.go similarity index 100% rename from cmd/protoc-gen-cpp-tableau-loader/ordered_map/ordered_map.go rename to cmd/protoc-gen-cpp-tableau-loader/orderedmap/ordered_map.go diff --git a/cmd/protoc-gen-go-tableau-loader/messager.go b/cmd/protoc-gen-go-tableau-loader/messager.go index e74acdb8..54760391 100644 --- a/cmd/protoc-gen-go-tableau-loader/messager.go +++ b/cmd/protoc-gen-go-tableau-loader/messager.go @@ -5,8 +5,8 @@ import ( "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/helper" idx "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/index" - orderedindex "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/ordered_index" - orderedmap "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/ordered_map" + "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/orderedindex" + "github.com/tableauio/loader/cmd/protoc-gen-go-tableau-loader/orderedmap" "github.com/tableauio/loader/internal/extensions" "github.com/tableauio/loader/internal/index" "github.com/tableauio/loader/internal/options" diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go b/cmd/protoc-gen-go-tableau-loader/orderedindex/ordered_index.go similarity index 100% rename from cmd/protoc-gen-go-tableau-loader/ordered_index/ordered_index.go rename to cmd/protoc-gen-go-tableau-loader/orderedindex/ordered_index.go diff --git a/cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go b/cmd/protoc-gen-go-tableau-loader/orderedmap/ordered_map.go similarity index 100% rename from cmd/protoc-gen-go-tableau-loader/ordered_map/ordered_map.go rename to cmd/protoc-gen-go-tableau-loader/orderedmap/ordered_map.go