func addBSON(b []byte, doc interface{}) ([]byte, os.Error) { data, err := bson.Marshal(doc) if err != nil { return b, err } return append(b, data...), nil }
func (s *S) TestMarshalOneWayItems(c *C) { for _, item := range marshalItems { data, err := bson.Marshal(item.obj) c.Assert(err, IsNil) c.Assert(string(data), Equals, wrapInDoc(item.data)) } }
func (s *S) TestMarshalErrorItems(c *C) { for _, item := range marshalErrorItems { data, err := bson.Marshal(item.obj) c.Assert(err, Matches, item.data) c.Assert(data, IsNil) } }
func (s *S) TestMarshalAllItems(c *C) { for i, item := range allItems { data, err := bson.Marshal(item.obj) c.Assert(err, IsNil) c.Assert(string(data), Equals, wrapInDoc(item.data), Bug("Failed on item %d: %#v", i, item)) } }
func (s *S) TestMarshalSampleItems(c *C) { for i, item := range sampleItems { data, err := bson.Marshal(item.obj) c.Assert(err, IsNil) c.Assert(string(data), Equals, item.data, Bug("Failed on item %d", i)) } }
func (s *S) TestMarshalShortWithGetter(c *C) { obj := typeWithIntGetter{42} data, err := bson.Marshal(obj) c.Assert(err, IsNil) m := bson.M{} err = bson.Unmarshal(data, m) c.Assert(m["v"], Equals, 42) }
func testCrossPair(c *C, dump interface{}, load interface{}, bug interface{}) { //c.Logf("") zero := makeZeroDoc(load) data, err := bson.Marshal(dump) c.Assert(err, IsNil, bug) c.Logf("Data: %#v", string(data)) err = bson.Unmarshal(data, zero) c.Assert(err, IsNil, bug) c.Assert(zero, Equals, load, bug) }
// SetInfo changes the optional metadata associated with the file. // For example: // // file.SetInfo(bson.M{"inode": inode}) // // It is a runtime error to call this function when the file is not open // for writing. func (file *GridFile) SetInfo(metadata interface{}) { file.assertMode(gfsWriting) data, err := bson.Marshal(metadata) file.m.Lock() if err != nil && file.err == nil { file.err = err } else { file.doc.Metadata = &bson.Raw{Data: data} } file.m.Unlock() }
func (s *S) TestMarshalAllItemsWithGetter(c *C) { for i, item := range allItems { if item.data == "" { continue } obj := &docWithGetterField{} obj.Field = &typeWithGetter{item.obj.(bson.M)["_"]} data, err := bson.Marshal(obj) c.Assert(err, IsNil) c.Assert(string(data), Equals, wrapInDoc(item.data), Bug("Failed on item #%d", i)) } }
func main() { var inter [4]interface{} in1 := 1 in2 := [...]int{1, 2, 3} in3 := []byte("womengde") in4 := "dfdfdfd" inter[0] = in1 inter[1] = in2 inter[2] = in3 inter[3] = in4 data, _ := bson.Marshal(inter) fmt.Printf("%#v\n", data) bson.Unmarshal(data, inter) fmt.Printf("%#v\n", inter) }
func (file *GridFile) insertChunk(data []byte) { n := file.chunk file.chunk++ debugf("GridFile %p: adding to checksum: %q", file, string(data)) file.wsum.Write(data) for file.doc.ChunkSize*file.wpending >= 1024*1024 { // Hold on.. we got a MB pending. file.c.Wait() if file.err != nil { return } } file.wpending++ debugf("GridFile %p: inserting chunk %d with %d bytes", file, n, len(data)) // We may not own the memory of data, so rather than // simply copying it, we'll marshal the document ahead of time. data, err := bson.Marshal(gfsChunk{bson.NewObjectId(), file.doc.Id, n, data}) if err != nil { file.err = err return } go func() { err := file.gfs.Chunks.Insert(bson.Raw{Data: data}) file.m.Lock() file.wpending-- if err != nil && file.err == nil { file.err = err } file.c.Broadcast() file.m.Unlock() }() }
func (s *S) TestMarshalWholeDocumentWithGetter(c *C) { obj := &typeWithGetter{sampleItems[0].obj} data, err := bson.Marshal(obj) c.Assert(err, IsNil) c.Assert(string(data), Equals, sampleItems[0].data) }