| // Go support for Protocol Buffers - Google's data interchange format |
| // |
| // Copyright 2010 The Go Authors. All rights reserved. |
| // https://github.com/golang/protobuf |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package proto |
| |
| /* |
| * Support for message sets. |
| */ |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "reflect" |
| "sort" |
| ) |
| |
| // ErrNoMessageTypeId occurs when a protocol buffer does not have a message type ID. |
| // A message type ID is required for storing a protocol buffer in a message set. |
| var ErrNoMessageTypeId = errors.New("proto does not have a message type ID") |
| |
| // The first two types (_MessageSet_Item and MessageSet) |
| // model what the protocol compiler produces for the following protocol message: |
| // message MessageSet { |
| // repeated group Item = 1 { |
| // required int32 type_id = 2; |
| // required string message = 3; |
| // }; |
| // } |
| // That is the MessageSet wire format. We can't use a proto to generate these |
| // because that would introduce a circular dependency between it and this package. |
| // |
| // When a proto1 proto has a field that looks like: |
| // optional message<MessageSet> info = 3; |
| // the protocol compiler produces a field in the generated struct that looks like: |
| // Info *_proto_.MessageSet `protobuf:"bytes,3,opt,name=info"` |
| // The package is automatically inserted so there is no need for that proto file to |
| // import this package. |
| |
| type _MessageSet_Item struct { |
| TypeId *int32 `protobuf:"varint,2,req,name=type_id"` |
| Message []byte `protobuf:"bytes,3,req,name=message"` |
| } |
| |
| type MessageSet struct { |
| Item []*_MessageSet_Item `protobuf:"group,1,rep"` |
| XXX_unrecognized []byte |
| // TODO: caching? |
| } |
| |
| // Make sure MessageSet is a Message. |
| var _ Message = (*MessageSet)(nil) |
| |
| // messageTypeIder is an interface satisfied by a protocol buffer type |
| // that may be stored in a MessageSet. |
| type messageTypeIder interface { |
| MessageTypeId() int32 |
| } |
| |
| func (ms *MessageSet) find(pb Message) *_MessageSet_Item { |
| mti, ok := pb.(messageTypeIder) |
| if !ok { |
| return nil |
| } |
| id := mti.MessageTypeId() |
| for _, item := range ms.Item { |
| if *item.TypeId == id { |
| return item |
| } |
| } |
| return nil |
| } |
| |
| func (ms *MessageSet) Has(pb Message) bool { |
| if ms.find(pb) != nil { |
| return true |
| } |
| return false |
| } |
| |
| func (ms *MessageSet) Unmarshal(pb Message) error { |
| if item := ms.find(pb); item != nil { |
| return Unmarshal(item.Message, pb) |
| } |
| if _, ok := pb.(messageTypeIder); !ok { |
| return ErrNoMessageTypeId |
| } |
| return nil // TODO: return error instead? |
| } |
| |
| func (ms *MessageSet) Marshal(pb Message) error { |
| msg, err := Marshal(pb) |
| if err != nil { |
| return err |
| } |
| if item := ms.find(pb); item != nil { |
| // reuse existing item |
| item.Message = msg |
| return nil |
| } |
| |
| mti, ok := pb.(messageTypeIder) |
| if !ok { |
| return ErrNoMessageTypeId |
| } |
| |
| mtid := mti.MessageTypeId() |
| ms.Item = append(ms.Item, &_MessageSet_Item{ |
| TypeId: &mtid, |
| Message: msg, |
| }) |
| return nil |
| } |
| |
| func (ms *MessageSet) Reset() { *ms = MessageSet{} } |
| func (ms *MessageSet) String() string { return CompactTextString(ms) } |
| func (*MessageSet) ProtoMessage() {} |
| |
| // Support for the message_set_wire_format message option. |
| |
| func skipVarint(buf []byte) []byte { |
| i := 0 |
| for ; buf[i]&0x80 != 0; i++ { |
| } |
| return buf[i+1:] |
| } |
| |
| // MarshalMessageSet encodes the extension map represented by m in the message set wire format. |
| // It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. |
| func MarshalMessageSet(m map[int32]Extension) ([]byte, error) { |
| if err := encodeExtensionMap(m); err != nil { |
| return nil, err |
| } |
| |
| // Sort extension IDs to provide a deterministic encoding. |
| // See also enc_map in encode.go. |
| ids := make([]int, 0, len(m)) |
| for id := range m { |
| ids = append(ids, int(id)) |
| } |
| sort.Ints(ids) |
| |
| ms := &MessageSet{Item: make([]*_MessageSet_Item, 0, len(m))} |
| for _, id := range ids { |
| e := m[int32(id)] |
| // Remove the wire type and field number varint, as well as the length varint. |
| msg := skipVarint(skipVarint(e.enc)) |
| |
| ms.Item = append(ms.Item, &_MessageSet_Item{ |
| TypeId: Int32(int32(id)), |
| Message: msg, |
| }) |
| } |
| return Marshal(ms) |
| } |
| |
| // UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. |
| // It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. |
| func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error { |
| ms := new(MessageSet) |
| if err := Unmarshal(buf, ms); err != nil { |
| return err |
| } |
| for _, item := range ms.Item { |
| id := *item.TypeId |
| msg := item.Message |
| |
| // Restore wire type and field number varint, plus length varint. |
| // Be careful to preserve duplicate items. |
| b := EncodeVarint(uint64(id)<<3 | WireBytes) |
| if ext, ok := m[id]; ok { |
| // Existing data; rip off the tag and length varint |
| // so we join the new data correctly. |
| // We can assume that ext.enc is set because we are unmarshaling. |
| o := ext.enc[len(b):] // skip wire type and field number |
| _, n := DecodeVarint(o) // calculate length of length varint |
| o = o[n:] // skip length varint |
| msg = append(o, msg...) // join old data and new data |
| } |
| b = append(b, EncodeVarint(uint64(len(msg)))...) |
| b = append(b, msg...) |
| |
| m[id] = Extension{enc: b} |
| } |
| return nil |
| } |
| |
| // MarshalMessageSetJSON encodes the extension map represented by m in JSON format. |
| // It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. |
| func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) { |
| var b bytes.Buffer |
| b.WriteByte('{') |
| |
| // Process the map in key order for deterministic output. |
| ids := make([]int32, 0, len(m)) |
| for id := range m { |
| ids = append(ids, id) |
| } |
| sort.Sort(int32Slice(ids)) // int32Slice defined in text.go |
| |
| for i, id := range ids { |
| ext := m[id] |
| if i > 0 { |
| b.WriteByte(',') |
| } |
| |
| msd, ok := messageSetMap[id] |
| if !ok { |
| // Unknown type; we can't render it, so skip it. |
| continue |
| } |
| fmt.Fprintf(&b, `"[%s]":`, msd.name) |
| |
| x := ext.value |
| if x == nil { |
| x = reflect.New(msd.t.Elem()).Interface() |
| if err := Unmarshal(ext.enc, x.(Message)); err != nil { |
| return nil, err |
| } |
| } |
| d, err := json.Marshal(x) |
| if err != nil { |
| return nil, err |
| } |
| b.Write(d) |
| } |
| b.WriteByte('}') |
| return b.Bytes(), nil |
| } |
| |
| // UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. |
| // It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. |
| func UnmarshalMessageSetJSON(buf []byte, m map[int32]Extension) error { |
| // Common-case fast path. |
| if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { |
| return nil |
| } |
| |
| // This is fairly tricky, and it's not clear that it is needed. |
| return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented") |
| } |
| |
| // A global registry of types that can be used in a MessageSet. |
| |
| var messageSetMap = make(map[int32]messageSetDesc) |
| |
| type messageSetDesc struct { |
| t reflect.Type // pointer to struct |
| name string |
| } |
| |
| // RegisterMessageSetType is called from the generated code. |
| func RegisterMessageSetType(m Message, fieldNum int32, name string) { |
| messageSetMap[fieldNum] = messageSetDesc{ |
| t: reflect.TypeOf(m), |
| name: name, |
| } |
| } |