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
}