func (gs *granularStorage) set(i int, b []byte) error { if i < 0 || i >= gs.len() { return ErrIndexOutOfRange } enc := encdec.NewEnc() enc.ByteSlice(b) if enc.Error() != nil { return enc.Error() } if enc.Len() > gs.granularity { err := gs.rebuild(enc.Len()) if err != nil { return err } } // fmt.Printf("set: %v %v %v\n", i, b, enc.Bytes()) n, err := gs.data.WriteAt(enc.Bytes(), int64(i*gs.granularity)) if err != nil { return err } if n != enc.Len() { return errStorage } return nil }
func (u *user) MarshalBinary() ([]byte, error) { enc := encdec.NewEnc() enc.ByteSlice([]byte(u.name)) enc.Int64(int64(u.age)) enc.Marshaler(u.registered) return enc.Bytes(), enc.Error() }
func (gs *granularStorage) del(i int) error { if i < 0 || i >= gs.len() { return ErrIndexOutOfRange } enc := encdec.NewEnc() enc.ByteSlice(delcom) if enc.Error() != nil { return enc.Error() } // if enc.Len() > gs.granularity { // // err := gs.rebuild(enc.Len()) // // if err != nil { // // return err // // } // return errStorage // } n, err := gs.data.WriteAt(enc.Bytes(), int64(i*gs.granularity)) if err != nil { return err } if n != enc.Len() { return errStorage } gs.freeSlots = append(gs.freeSlots, i) return nil }
func (gs *granularStorage) add(b []byte) (int, error) { if len(gs.freeSlots) > 0 { fs := gs.freeSlots[0] gs.freeSlots = gs.freeSlots[1:] return gs.len() - 1, gs.set(fs, b) } enc := encdec.NewEnc() enc.ByteSlice(b) if enc.Error() != nil { return 0, enc.Error() } if enc.Len() > gs.granularity { err := gs.rebuild(enc.Len()) if err != nil { return -1, err } } nb := append(enc.Bytes(), make([]byte, gs.granularity-enc.Len())...) // fmt.Printf("add: %v %v\n", b, nb) n, err := gs.data.WriteAt(nb, int64(gs.len()*gs.granularity)) if err != nil { return 0, err } if n != len(nb) { return 0, errStorage } gs.length++ return gs.len() - 1, nil }
func (h *head) MarshalBinary() ([]byte, error) { enc := encdec.NewEnc() enc.Int64(h.offset) // enc.ByteSlice(h.entityDesc) enc.Uint64(uint64(h.bodyLen)) // h.eID = enc.Bytes() return enc.Bytes(), enc.Error() }
func (t *fuzzTestType) MarshalBinary() ([]byte, error) { enc := encdec.NewEnc() enc.Uint64(t.a) enc.Uint64(t.a) enc.Int64(t.b) enc.Int64(t.b) enc.Float64(t.c) enc.Float64(t.c) enc.ByteSlice(t.d) enc.ByteSlice(t.d) enc.Marshaler(&t.e) enc.Marshaler(&t.e) return enc.Bytes(), enc.Error() }
func testGenerateCorpus(t *testing.T) { i := 0 if err := quick.Check(func(x1 uint64, y1 int64, f1 float64, buf1 []byte) bool { fi, _ := os.Create(fmt.Sprintf("corpus/init%v", i)) i++ v := fuzzTestType{x1, y1, f1, buf1, time.Now()} enc := encdec.NewEnc() enc.Marshaler(&v) fi.Write(enc.Bytes()) fi.Close() return true }, nil); err != nil { t.Error(err) } }
func (e *Entity) compile(off int64) ([]byte, error) { if e.h.offset < 0 { e.h.offset = off } enc := encdec.NewEnc() enc.Marshaler(&e.h) if e.h.entityID == nil { e.h.entityID = enc.Bytes() } // fmt.Printf("%v\n", e.h.eID) enc.ByteSlice(e.Body) enc.Uint64(uint64(len(e.Tags))) for _, t := range e.Tags { enc.ByteSlice([]byte(t)) } return enc.Bytes(), enc.Error() }
func Example() { //encode data to byte slice enc := encdec.NewEnc() enc.Uint64(uint64(len(users))) for _, u := range users { enc.Marshaler(&u) } if enc.Error() != nil { panic(enc.Error()) } slice := enc.Bytes() //decode data from byte slice dec := encdec.NewDec(slice) l := int(dec.Uint64()) users = make([]user, l) for i := 0; i < l; i++ { dec.Unmarshaler(&users[i]) } if dec.Error() != nil { panic(dec.Error()) } }
func Fuzz(data []byte) int { var v fuzzTestType dec := encdec.NewDec(data) dec.Unmarshaler(&v) if dec.Error() != nil { return 0 } enc := encdec.NewEnc() enc.Marshaler(&v) if enc.Error() != nil { panic(enc.Error()) } var v1 fuzzTestType dec = encdec.NewDec(enc.Bytes()) dec.Unmarshaler(&v1) if dec.Error() != nil { panic(dec.Error()) } if !reflect.DeepEqual(v, v1) { panic("not equal") } return 1 }