doc.go

package purejson

import (
	"fmt"
	"os"
	"runtime"
	"sync"

	"github.com/amikos-tech/pure-simdjson/internal/ffi"
)

// Doc wraps one live native document handle plus its cached root view.
type Doc struct {
	mu     sync.Mutex
	parser *Parser
	handle ffi.DocHandle
	root   ffi.ValueView
	closed bool
}

// Root returns the cached root element view for the live document.
func (d *Doc) Root() Element {
	return Element{doc: d, view: d.root}
}

// Close releases the native document and clears the owning parser's busy
// state. It is idempotent.
func (d *Doc) Close() error {
	d.mu.Lock()
	if d.closed {
		d.mu.Unlock()
		return nil
	}

	handle := d.handle
	parser := d.parser
	library := parser.library

	clearDocFinalizer(d)
	rc := library.bindings.DocFree(handle)
	runtime.KeepAlive(d)
	runtime.KeepAlive(d.parser)
	if err := wrapStatus(rc); err != nil {
		attachDocFinalizer(d)
		d.mu.Unlock()
		if leakWarningsEnabled() {
			fmt.Fprintf(os.Stderr, "purejson close-failed: doc %v\n", err)
		}
		return err
	}

	d.closed = true
	d.handle = 0
	d.mu.Unlock()

	parser.clearLiveDoc(handle)
	return nil
}

func (d *Doc) isClosed() bool {
	// Use TryLock rather than Lock: callers on the fast path may hold d.mu
	// already; blocking here would deadlock. Contention therefore reports
	// "not closed" -- the outer caller's own guard surfaces ErrParserBusy.
	if d.mu.TryLock() {
		closed := d.closed
		d.mu.Unlock()
		return closed
	}
	return false
}

func (d *Doc) hasLeakedState() bool {
	d.mu.Lock()
	defer d.mu.Unlock()
	return !d.closed && d.handle != 0
}

// finalizeLeaked frees the native document from the GC finalizer. It releases
// the mutex around the FFI call so a stuck native side cannot hold the runtime,
// then re-acquires it to commit state only when the free succeeded.
func (d *Doc) finalizeLeaked() {
	d.mu.Lock()
	if d.closed {
		d.mu.Unlock()
		return
	}

	handle := d.handle
	parser := d.parser
	library := parser.library
	d.mu.Unlock()

	rc := library.bindings.DocFree(handle)
	docFreed := rc == int32(ffi.OK)
	if docFreed {
		docFinalizerCount.Add(1)
	}

	d.mu.Lock()
	if docFreed {
		d.closed = true
		d.handle = 0
	}
	d.mu.Unlock()

	if docFreed {
		parser.clearLiveDoc(handle)
	}
}