fix(all): impl. new apis to make sure safety

Author: fumiama

item.go

@@ -2,7 +2,6 @@ package orbyte
 
 import (
 	"runtime"
-	"strconv"
 	"sync/atomic"
 )
 
@@ -16,96 +15,59 @@ type Item[T any] struct {
 	cfg  any
 
 	stat status
-	ref  *Item[T]
-	refc int32 // refc -1 means transferred / destroyed
 
 	val T
 }
 
-func (b *Item[T]) incref() {
-	atomic.AddInt32(&b.refc, 1)
-}
-
-func (b *Item[T]) decref() {
-	atomic.AddInt32(&b.refc, -1)
-}
-
-// Trans ownership to a new item and
-// destroy original item immediately.
-//
-// The value in new item will not be Reset().
+// Trans disable inner val being reset by
+// destroy and return a safe copy of val.
 //
-// Call this function to drop your ownership
-// before passing it to another function
-// that is not controlled by you.
+// This method is not thread-safe.
+// Only call once on one item.
+// The item will be destroyed after calling Trans().
 //
-// Avoid to call this function after calling Ref().
-func (b *Item[T]) Trans() (tb *Item[T]) {
+// Use it to drop your ownership
+// before passing val (not its pointer)
+// to another function that is not controlled by you.
+func (b *Item[T]) Trans() T {
 	if b.stat.hasdestroyed() {
 		panic("use after destroy")
 	}
-	if b.ref != nil {
-		panic("cannot trans ref")
-	}
-	tb = b.pool.newempty()
-	*tb = *b
-	tb.stat = status(atomic.SwapUintptr(
+	val := b.val
+	atomic.StoreUintptr(
 		(*uintptr)(&b.stat), uintptr(destroyedstatus),
-	))
-	tb.refc = 0
-	tb.stat.setintrans(true)
-	b.destroybystat(status(0))
-	return tb
+	)
+	runtime.KeepAlive(b)
+	b.destroybystat(0)
+	return val
 }
 
-// HasInvolved whether this item is buffered.
+// HasInvolved whether this item is buffered
+// and will be Reset on putting back.
 func (b *Item[T]) HasInvolved() bool {
 	return b.stat.isbuffered()
 }
 
-// IsTrans whether this item has been marked as trans.
-func (b *Item[T]) IsTrans() bool {
-	return b.stat.isintrans()
-}
-
-// IsRef whether this item is a reference.
-func (b *Item[T]) IsRef() bool {
-	return b.ref != nil
-}
-
-// Unwrap use value of the item
-func (b *Item[T]) Unwrap() T {
-	if b.stat.hasdestroyed() {
-		panic("use after destroy")
-	}
-	return b.val
-}
-
-// Pointer use pointer value of the item
-func (b *Item[T]) Pointer() *T {
+// V use value of the item.
+//
+// This operation is safe in function f.
+func (b *Item[T]) V(f func(T)) {
 	if b.stat.hasdestroyed() {
 		panic("use after destroy")
 	}
-	return &b.val
+	f(b.val)
+	runtime.KeepAlive(b)
 }
 
-// Ref gens new item without ownership.
+// P use pointer value of the item.
 //
-// It's a safe reference, thus calling this
-// will not destroy the original item
-// comparing with Trans().
-func (b *Item[T]) Ref() (rb *Item[T]) {
+// This operation is safe in function f.
+func (b *Item[T]) P(f func(*T)) {
 	if b.stat.hasdestroyed() {
 		panic("use after destroy")
 	}
-	rb = b.pool.newempty()
-	*rb = *b
-	rb.ref = b
-	rb.refc = 0
-	b.incref()
-	rb.stat.setbuffered(false)
-	rb.stat.setintrans(false)
-	return
+	f(&b.val)
+	runtime.KeepAlive(b)
 }
 
 // Copy data completely with separated ownership.
@@ -119,21 +81,9 @@ func (b *Item[T]) Copy() (cb *Item[T]) {
 }
 
 func (b *Item[T]) destroybystat(stat status) {
-	if !atomic.CompareAndSwapInt32(&b.refc, 0, -1) {
-		if b.refc < 0 {
-			panic("use imm. after destroy")
-		}
-		panic("cannot destroy: " + strconv.Itoa(int(b.refc)) + " refs remained")
-	}
-	if b.ref != nil {
-		defer b.ref.decref()
-	}
 	switch {
 	case stat.hasdestroyed():
-		panic("use after put back to pool")
-	case stat.isintrans():
-		var v T
-		b.val = v
+		panic("destroy after destroy")
 	case stat.isbuffered():
 		b.pool.pooler.Reset(&b.val)
 	default:
@@ -158,10 +108,10 @@ func (b *Item[T]) ManualDestroy() {
 // Only can call once.
 func (b *Item[T]) setautodestroy() *Item[T] {
 	runtime.SetFinalizer(b, func(item *Item[T]) {
-		// no one is using, no concurrency issue.
 		if item.stat.hasdestroyed() {
 			panic("unexpected hasdestroyed")
 		}
+		// no one is using, no concurrency issue.
 		item.destroybystat(item.stat)
 	})
 	return b

pbuf/buffer.go

@@ -2,7 +2,6 @@ package pbuf
 
 import (
 	"bytes"
-	"unsafe"
 
 	"github.com/fumiama/orbyte"
 )
@@ -21,54 +20,3 @@ func (bufferPool BufferPool) InvolveBuffer(buf *bytes.Buffer) *orbyte.Item[bytes
 func (bufferPool BufferPool) ParseBuffer(buf *bytes.Buffer) *orbyte.Item[bytes.Buffer] {
 	return bufferPool.p.Parse(buf.Len(), buf)
 }
-
-// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
-// The zero value for Buffer is an empty buffer ready to use.
-type buffer struct {
-	buf      []byte // contents are the bytes buf[off : len(buf)]
-	off      int    // read at &buf[off], write at &buf[len(buf)]
-	lastRead readOp // last read operation, so that Unread* can work correctly.
-}
-
-func skip(w *bytes.Buffer, n int) {
-	if n == 0 {
-		return
-	}
-	b := (*buffer)(unsafe.Pointer(w))
-	b.lastRead = opInvalid
-	if len(b.buf) <= b.off {
-		// Buffer is empty, reset to recover space.
-		w.Reset()
-		return
-	}
-	n = minnum(n, len(b.buf[b.off:]))
-	b.off += n
-	if n > 0 {
-		b.lastRead = opRead
-	}
-}
-
-// The readOp constants describe the last action performed on
-// the buffer, so that UnreadRune and UnreadByte can check for
-// invalid usage. opReadRuneX constants are chosen such that
-// converted to int they correspond to the rune size that was read.
-type readOp int8
-
-// Don't use iota for these, as the values need to correspond with the
-// names and comments, which is easier to see when being explicit.
-const (
-	opRead      readOp = -1 // Any other read operation.
-	opInvalid   readOp = 0  // Non-read operation.
-	opReadRune1 readOp = 1  // Read rune of size 1.
-	opReadRune2 readOp = 2  // Read rune of size 2.
-	opReadRune3 readOp = 3  // Read rune of size 3.
-	opReadRune4 readOp = 4  // Read rune of size 4.
-)
-
-// minnum 返回两数最小值，该函数将被内联
-func minnum[T int | int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64](a, b T) T {
-	if a > b {
-		return b
-	}
-	return a
-}

pbuf/buffer_test.go

@@ -20,38 +20,24 @@ func TestBuffer(t *testing.T) {
 }
 
 func testBuffer(buf *orbyte.Item[bytes.Buffer], t *testing.T) {
-	if buf.Pointer().Len() != 4096 {
-		io.CopyN(buf.Pointer(), rand.Reader, 4096)
-		if buf.Pointer().Len() != 4096 {
-			t.Fatal("got", buf.Pointer().Len())
+	buf.P(func(buf *bytes.Buffer) {
+		if buf.Len() != 4096 {
+			io.CopyN(buf, rand.Reader, 4096)
+			if buf.Len() != 4096 {
+				t.Fatal("got", buf.Len())
+			}
 		}
-	}
-
+	})
 	bufcp := buf.Copy()
-	if bufcp.Pointer().Len() != 4096 {
-		t.Fatal("got", bufcp.Pointer().Len())
-	}
-	if !bytes.Equal(bufcp.Pointer().Bytes(), buf.Pointer().Bytes()) {
-		t.Fatal("unexpected")
-	}
-
-	bufr := buf.Ref()
-	if bufr.Pointer().Len() != 4096 {
-		t.Fatal("got", bufr.Pointer().Len())
-	}
-	if !bytes.Equal(bufr.Pointer().Bytes(), buf.Pointer().Bytes()) {
-		t.Fatal("unexpected")
-	}
-	bufr.ManualDestroy()
-
-	bufcp = bufcp.Trans()
-	if bufcp.Pointer().Len() != 4096 {
-		t.Fatal("got", bufcp.Pointer().Len())
-	}
-	if !bytes.Equal(bufcp.Pointer().Bytes(), buf.Pointer().Bytes()) {
-		t.Fatal("unexpected")
-	}
-	bufcp.ManualDestroy()
+	dat := buf.Trans()
+	bufcp.P(func(bufcp *bytes.Buffer) {
+		if bufcp.Len() != 4096 {
+			t.Fatal("got", bufcp.Len())
+		}
+		if !bytes.Equal(bufcp.Bytes(), dat.Bytes()) {
+			t.Fatal("unexpected")
+		}
+	})
 
 	runtime.GC()
 	runtime.Gosched()