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())
}
