Пример #1
0
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
}
Пример #2
0
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()
}
Пример #3
0
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
}
Пример #4
0
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
}
Пример #5
0
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()
}
Пример #6
0
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()
}
Пример #7
0
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)
	}
}
Пример #8
0
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()
}
Пример #9
0
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())
	}
}
Пример #10
0
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
}