// Build creates the defRefsIndex.
func (x *defRefsIndex) Build(refs []*graph.Ref, fbr fileByteRanges, ofs byteOffsets) error {
vlog.Printf("defRefsIndex: building inverted def->ref index (%d refs)...", len(refs))
defToRefOfs := map[graph.RefDefKey]byteOffsets{}
for i, ref := range refs {
defToRefOfs[ref.RefDefKey()] = append(defToRefOfs[ref.RefDefKey()], ofs[i])
}
vlog.Printf("defRefsIndex: adding %d index phtable keys...", len(defToRefOfs))
b := phtable.Builder(len(fbr))
for def, refOfs := range defToRefOfs {
v, err := binary.Marshal(refOfs)
if err != nil {
return err
}
k, err := proto.Marshal(&def)
if err != nil {
return err
}
b.Add([]byte(k), v)
}
vlog.Printf("defRefsIndex: building index phtable...")
h, err := b.Build()
if err != nil {
return err
}
h.StoreKeys = true // so defRefUnitsIndex can enumerate defs pointed to by this unit's refs
x.phtable = h
x.ready = true
vlog.Printf("defRefsIndex: done building index.")
return nil
}
func (w *varintWriter) WriteMsg(msg proto.Message) (uint64, error) {
var data []byte
if m, ok := msg.(marshaler); ok {
n := m.Size()
if n >= len(w.buf) {
w.buf = make([]byte, n)
}
if _, err := m.MarshalTo(w.buf); err != nil {
return 0, err
}
data = w.buf[:n]
} else {
var err error
data, err = proto.Marshal(msg)
if err != nil {
return 0, err
}
}
length := uint64(len(data))
n := binary.PutUvarint(w.lenBuf, length)
if _, err := w.w.Write(w.lenBuf[:n]); err != nil {
return 0, err
}
_, err := w.w.Write(data)
return uint64(n) + length, err
}
func newTestMessage() *pb.MyMessage {
msg := &pb.MyMessage{
Count: proto.Int32(42),
Name: proto.String("Dave"),
Quote: proto.String(`"I didn't want to go."`),
Pet: []string{"bunny", "kitty", "horsey"},
Inner: &pb.InnerMessage{
Host: proto.String("footrest.syd"),
Port: proto.Int32(7001),
Connected: proto.Bool(true),
},
Others: []*pb.OtherMessage{
{
Key: proto.Int64(0xdeadbeef),
Value: []byte{1, 65, 7, 12},
},
{
Weight: proto.Float32(6.022),
Inner: &pb.InnerMessage{
Host: proto.String("lesha.mtv"),
Port: proto.Int32(8002),
},
},
},
Bikeshed: pb.MyMessage_BLUE.Enum(),
Somegroup: &pb.MyMessage_SomeGroup{
GroupField: proto.Int32(8),
},
// One normally wouldn't do this.
// This is an undeclared tag 13, as a varint (wire type 0) with value 4.
XXX_unrecognized: []byte{13<<3 | 0, 4},
}
ext := &pb.Ext{
Data: proto.String("Big gobs for big rats"),
}
if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil {
panic(err)
}
greetings := []string{"adg", "easy", "cow"}
if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil {
panic(err)
}
// Add an unknown extension. We marshal a pb.Ext, and fake the ID.
b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")})
if err != nil {
panic(err)
}
b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...)
proto.SetRawExtension(msg, 201, b)
// Extensions can be plain fields, too, so let's test that.
b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19)
proto.SetRawExtension(msg, 202, b)
return msg
}
func (x *defRefsIndex) getByDef(def graph.RefDefKey) (byteOffsets, bool, error) {
c_defRefsIndex_getByDef++
if x.phtable == nil {
panic("phtable not built/read")
}
k, err := proto.Marshal(&def)
if err != nil {
return nil, false, err
}
v := x.phtable.Get(k)
if v == nil {
return nil, false, nil
}
var ofs byteOffsets
if err := binary.Unmarshal(v, &ofs); err != nil {
return nil, true, err
}
return ofs, true, nil
}