func new(rootPackage string, rootMessage string, descSet *descriptor.FileDescriptorSet, path string) (*fdesc, error) {
fieldpaths := strings.Split(path, ".")
keys := make([]uint64, len(fieldpaths))
fields := make([]*descriptor.FieldDescriptorProto, len(fieldpaths))
curPackage := rootPackage
curMessage := rootMessage
last := len(fieldpaths) - 1
var fieldDesc *descriptor.FieldDescriptorProto
for i, f := range fieldpaths {
fieldName := f
fieldDesc = descSet.GetField(curPackage, curMessage, fieldName)
if fieldDesc == nil {
curPackage, fieldDesc = descSet.FindExtension(curPackage, curMessage, fieldName)
if fieldDesc == nil {
return nil, &errChild{fieldName: fieldName, pkg: curPackage, msg: curMessage}
}
typeNames := strings.Split(fieldDesc.GetTypeName(), ".")
curMessage = fieldDesc.GetTypeName()
if len(typeNames) > 1 {
curPackage = typeNames[1]
curMessage = typeNames[2]
}
fieldKey := fieldDesc.GetKeyUint64()
keys[i] = fieldKey
fields[i] = fieldDesc
} else {
fieldKey := fieldDesc.GetKeyUint64()
if fieldDesc.IsMessage() {
curPackage, curMessage = descSet.FindMessage(curPackage, curMessage, fieldName)
} else if i != last {
return nil, &errMessage{fieldName}
}
keys[i] = fieldKey
fields[i] = fieldDesc
}
}
fd := &fdesc{curPackage, curMessage, fields, fieldDesc, keys, 0}
if fieldDesc.GetType() == descriptor.FieldDescriptorProto_TYPE_ENUM {
typeNames := strings.Split(fieldDesc.GetTypeName(), ".")
enumMessage := fieldDesc.GetTypeName()
enumPackage := curPackage
if len(typeNames) > 1 {
enumPackage = typeNames[1]
enumMessage = typeNames[2]
}
enum := descSet.GetEnum(enumPackage, enumMessage)
if enum == nil {
return nil, &errChild{fieldName: fieldDesc.GetName(), pkg: enumPackage, msg: enumMessage}
}
for _, v := range enum.GetValue() {
if v.GetNumber() < fd.firstEnumValue {
fd.firstEnumValue = v.GetNumber()
}
}
}
return fd, nil
}
//Collapses a proto fieldpath into a go fieldpath. They are different if some of the fields in the fieldpath have been embedded.
func Collapse(rootPkg string, rootMsg string, path string, descriptorSet *descriptor.FileDescriptorSet) (string, error) {
msg := descriptorSet.GetMessage(rootPkg, rootMsg)
if msg == nil {
return "", &errUndefined{rootPkg, rootMsg, path}
}
paths := strings.Split(path, ".")
if len(paths) == 0 {
return "", &errUndefined{rootPkg, rootMsg, path}
}
if len(paths) == 1 {
return path, nil
}
for _, f := range msg.GetField() {
if f.GetName() != paths[0] {
continue
}
if f.IsMessage() {
newRootPkg, newRootMsg := descriptorSet.FindMessage(rootPkg, rootMsg, f.GetName())
if len(newRootPkg) == 0 || len(newRootMsg) == 0 {
return "", &errUndefined{rootPkg, rootMsg, path}
}
newPath, err := Collapse(newRootPkg, newRootMsg, strings.Join(paths[1:], "."), descriptorSet)
if err != nil {
return "", err
}
if gogoproto.IsEmbed(f) {
return newPath, nil
} else {
return paths[0] + "." + newPath, nil
}
}
}
if msg.IsExtendable() {
newRootPkg, f := descriptorSet.FindExtension(rootPkg, rootMsg, paths[0])
if f == nil {
return "", &errUndefined{rootPkg, rootMsg, path}
}
typeName := f.GetTypeName()
typeNames := strings.Split(typeName, ".")
newRootMsg := typeName
if len(typeNames) > 1 {
newRootMsg = typeNames[len(typeNames)-1]
}
newPath, err := Collapse(newRootPkg, newRootMsg, strings.Join(paths[1:], "."), descriptorSet)
if err != nil {
return "", err
}
if gogoproto.IsEmbed(f) {
return newPath, nil
} else {
return paths[0] + "." + newPath, nil
}
}
return "", nil
}
// The NoMerge function checks that the marshaled protocol buffer does not require any merging when unmarshaling
// When this property holds, streaming processing is possible.
//
// See below quotes from the protocol buffer documentation that describes how merging should work.
//
// https://developers.google.com/protocol-buffers/docs/encoding#optional
//
// Normally, an encoded message would never have more than one instance of an optional or required field.
// However, parsers are expected to handle the case in which they do.
// For numeric types and strings, if the same value appears multiple times, the parser accepts the last value it sees.
// For embedded message fields, the parser merges multiple instances of the same field,
// as if with the Message::MergeFrom method – that is,
// all singular scalar fields in the latter instance replace those in the former,
// singular embedded messages are merged, and repeated fields are concatenated.
// The effect of these rules is that parsing the concatenation of two encoded messages produces
// exactly the same result as if you had parsed the two messages separately and merged the resulting objects.
// That is, this:
//
// MyMessage message;
// message.ParseFromString(str1 + str2);
//
// is equivalent to this:
//
// MyMessage message, message2;
// message.ParseFromString(str1);
// message2.ParseFromString(str2);
// message.MergeFrom(message2);
//
// This property is occasionally useful, as it allows you to merge two messages even if you do not know their types.
//
// https://developers.google.com/protocol-buffers/docs/encoding#order
//
// However, protocol buffer parsers must be able to parse fields in any order,
// as not all messages are created by simply serializing an object – for instance,
// it's sometimes useful to merge two messages by simply concatenating them.
func NoMerge(buf []byte, descriptorSet *descriptor.FileDescriptorSet, rootPkg string, rootMsg string) error {
msg := descriptorSet.GetMessage(rootPkg, rootMsg)
if msg == nil {
return &errUndefined{rootPkg, rootMsg, ""}
}
i := 0
seen := make(map[int32]bool)
for i < len(buf) {
key, n, err := decodeVarint(buf, i)
if err != nil {
return err
}
i = i + n
fieldNum := int32(key >> 3)
wireType := int(key & 0x7)
field := getFieldNumber(descriptorSet, rootPkg, rootMsg, msg, fieldNum)
if field == nil || field.GetLabel() == descriptor.FieldDescriptorProto_LABEL_REPEATED {
i, err = skip(buf, i, wireType)
if err != nil {
return err
}
continue
}
if seen[fieldNum] {
return &errMerge{msg.GetName() + "." + field.GetName()}
}
seen[fieldNum] = true
if !field.IsMessage() {
i, err = skip(buf, i, wireType)
if err != nil {
return err
}
continue
}
length, n, err := decodeVarint(buf, i)
if err != nil {
return err
}
i += n
fieldPkg, fieldMsg := descriptorSet.FindMessage(rootPkg, rootMsg, field.GetName())
if len(fieldMsg) == 0 {
return &errUndefined{rootPkg, rootMsg, field.GetName()}
}
err = NoMerge(buf[i:i+int(length)], descriptorSet, fieldPkg, fieldMsg)
if err != nil {
return err
}
i += int(length)
}
return nil
}
func toMessages(elems []string, fileDescriptorSet *descriptor.FileDescriptorSet, messages []string) ([]string, error) {
if len(elems) < 2 {
return nil, &errUndefinedMsg{elems[0], "???"}
}
msg := fileDescriptorSet.GetMessage(elems[0], elems[1])
if msg == nil {
return nil, &errUndefinedMsg{elems[0], elems[1]}
}
if len(elems) == 2 {
messages = append(messages, elems[0]+"."+elems[1])
return messages, nil
}
newPkg, newMsg := fileDescriptorSet.FindMessage(elems[0], elems[1], elems[2])
if len(newMsg) == 0 {
return nil, &errUndefined{elems[0], elems[1], elems[2]}
}
messages = append(messages, elems[0]+"."+elems[1])
elems[1] = newPkg
elems[2] = newMsg
return toMessages(elems[1:], fileDescriptorSet, messages)
}