func (s *S) TestUnmarshalRawNil(c *C) { // Regression test: shouldn't try to nil out the pointer itself, // as it's not settable. raw := bson.Raw{0x0A, []byte{}} err := raw.Unmarshal(&struct{}{}) c.Assert(err, IsNil) }
func (self *DynamicChoice) SetBSON(raw bson.Raw) (err error) { var s string err = raw.Unmarshal(&s) if err != nil { return err } return self.SetString(s) }
func (s *S) TestUnmarshalRawStructItems(c *C) { for i, item := range structItems { raw := bson.Raw{0x03, []byte(wrapInDoc(item.data))} zero := makeZeroDoc(item.obj) err := raw.Unmarshal(zero) c.Assert(err, IsNil) c.Assert(zero, DeepEquals, item.obj, Commentf("Failed on item %d: %#v", i, item)) } }
func (t *Timestamp) SetBSON(raw bson.Raw) error { tim := new(time.Time) err := raw.Unmarshal(&tim) if err != nil { return err } *t = Timestamp{*tim} return nil }
func (o *setterType) SetBSON(raw bson.Raw) error { err := raw.Unmarshal(&o.received) if err != nil { panic("The panic:" + err.Error()) } if s, ok := o.received.(string); ok { if result, ok := setterResult[s]; ok { return result } } return nil }
// Implements bson.Setter for mongo.Ref compatibility. // Yes this bson dependency is dirty, but necessary // for transition form mongo.Ref to model.Ref. func (self *Ref) SetBSON(raw bson.Raw) error { var objectId *bson.ObjectId if raw.Unmarshal(&objectId) == nil { if objectId != nil { *self = Ref(objectId.Hex()) } else { *self = "" } return nil } return raw.Unmarshal(self) }
// SetBSON turns v into a bson.Setter so it can be loaded directly // from a MongoDB database with mgo. func (vp *Binary) SetBSON(raw bson.Raw) error { var s string err := raw.Unmarshal(&s) if err != nil { return err } v, err := ParseBinary(s) if err != nil { return err } *vp = v return nil }
// SetBSON updates the internal members with the data stored in the bson.Raw // parameter. func (t *Tools) SetBSON(raw bson.Raw) error { if raw.Kind == 10 { // Preserve the nil value in that case. return bson.SetZero } var doc toolsDoc if err := raw.Unmarshal(&doc); err != nil { return err } t.Binary = doc.Version t.URL = doc.URL return nil }
// Implements bson.Setter func (self *Ref) SetBSON(raw bson.Raw) error { var id *bson.ObjectId err := raw.Unmarshal(&id) if err != nil { return err } if id == nil { self.ID = "" } else { self.ID = *id } return nil }
// SetBSON turns u into a bson.Setter so it can be loaded directly // from a MongoDB database with mgo. func (u *URL) SetBSON(raw bson.Raw) error { if raw.Kind == 10 { return bson.SetZero } var s string err := raw.Unmarshal(&s) if err != nil { return err } url, err := ParseURL(s) if err != nil { return err } *u = *url return nil }
func (s *S) TestUnmarshalRawAllItems(c *C) { for i, item := range allItems { if len(item.data) == 0 { continue } value := item.obj.(bson.M)["_"] if value == nil { continue } pv := reflect.New(reflect.ValueOf(value).Type()) raw := bson.Raw{item.data[0], []byte(item.data[3:])} c.Logf("Unmarshal raw: %#v, %#v", raw, pv.Interface()) err := raw.Unmarshal(pv.Interface()) c.Assert(err, IsNil) c.Assert(pv.Elem().Interface(), DeepEquals, value, Commentf("Failed on item %d: %#v", i, item)) } }
func (key *PrivateKey) SetBSON(raw bson.Raw) (err error) { skey := &serializableKey{} err = raw.Unmarshal(skey) if err != nil { return } key.Id = skey.Id key.Type = skey.Type curve, err := getCurve(skey.Type) if err != nil { return } key.PrivateKey = &ecdsa.PrivateKey{ PublicKey: ecdsa.PublicKey{ Curve: curve, X: big.NewInt(0), Y: big.NewInt(0), }, D: big.NewInt(0), } var ok bool _, ok = key.X.SetString(skey.X, 0) if !ok { return fmt.Errorf("invalid X component: %s", skey.X) } _, ok = key.Y.SetString(skey.Y, 0) if !ok { return fmt.Errorf("invalid Y component: %s", skey.Y) } _, ok = key.D.SetString(skey.D, 0) if !ok { return fmt.Errorf("invalid D component: %s", skey.D) } return }
func (s *S) TestUnmarshalRawIncompatible(c *C) { raw := bson.Raw{0x08, []byte{0x01}} // true err := raw.Unmarshal(&struct{}{}) c.Assert(err, ErrorMatches, "BSON kind 0x08 isn't compatible with type struct \\{\\}") }
func (self *DynamicValue) SetBSON(raw bson.Raw) error { if self.Value == nil { panic("Can't SetBSON for nil model.Value") } return raw.Unmarshal(reflect.ValueOf(self.Value).Elem().Interface()) }