//nolint:staticcheck // SA6002 IT IS A GENERIC VALUE! (and always a pointer)
		h.reqPool.Put(r)
	}
}

// PutResponse will accept a response for reuse.
// These should be returned by the caller.
func (h *StreamTypeHandler[Payload, Req, Resp]) PutResponse(r Resp) {
	if r != h.nilResp {
		//nolint:staticcheck // SA6002 IT IS A GENERIC VALUE! (and always a pointer)
		h.respPool.Put(r)
	}
}

func (p *scannerMetrics) currentPathUpdater(disk, initial string) (update func(path string), done func()) {
	initialPtr := unsafe.Pointer(&initial)
	tracker := &currentPathTracker{
		name: &initialPtr,
	}

	p.currentPaths.Store(disk, tracker)
	return func(path string) {
			atomic.StorePointer(tracker.name, unsafe.Pointer(&path))
		}, func() {
			p.currentPaths.Delete(disk)
		}
}

pkg sync/atomic, method (*Int64) Store(int64) #50860
pkg sync/atomic, method (*Int64) Swap(int64) int64 #50860
pkg sync/atomic, method (*Pointer[$0]) CompareAndSwap(*$0, *$0) bool #50860
pkg sync/atomic, method (*Pointer[$0]) Load() *$0 #50860
pkg sync/atomic, method (*Pointer[$0]) Store(*$0) #50860
pkg sync/atomic, method (*Pointer[$0]) Swap(*$0) *$0 #50860
pkg sync/atomic, method (*Uint32) Add(uint32) uint32 #50860

	Namespace  string
}

// Inherit the common kubernetes flags defined in the root package. This is a bit of a hack,
// but it allows us to directly get the final values for each of these flags without needing
// to pass pointers-to-flags through all of the (sub)commands.
func (o *KubeOptions) prepare(ctx cli.Context) {
	o.Namespace = ctx.Namespace()
	if o.Namespace == "" {
		o.Namespace = ctx.IstioNamespace()

        short length = readShort();
        short maxLength = readShort();
        int pointer = readInt();

        if ( maxLength < length ) {
            throw new PACDecodingException("Malformed string in PAC");
        }

        return new PacUnicodeString(length, maxLength, pointer);
    }


    public String readString () throws IOException, PACDecodingException {

func (r *RingBuffer) WriteString(s string) (n int, err error) {
	x := (*[2]uintptr)(unsafe.Pointer(&s))
	h := [3]uintptr{x[0], x[1], x[1]}
	buf := *(*[]byte)(unsafe.Pointer(&h))
	return r.Write(buf)
}

// Bytes returns all available read bytes.
// It does not move the read pointer and only copy the available data.
// If the dst is big enough it will be used as destination,

// This function will block till the operation that produces `h` has
// completed. This is only valid on local TFE_TensorHandles. The pointer
// returned will be on the device in which the TFE_TensorHandle resides (so e.g.
// for a GPU tensor this will return a pointer to GPU memory). The pointer is
// only guaranteed to be valid until TFE_DeleteTensorHandle is called on this
// TensorHandle. Only supports POD data types.

	}
}

func TestParseSchemaWithPointerFields(t *testing.T) {
	user, err := schema.Parse(&User{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse pointer user, got error %v", err)
	}

	checkUserSchema(t, user)
}

func checkUserSchema(t *testing.T, user *schema.Schema) {
	// check schema

@SuppressWarnings ( "javadoc" )
public class NdrException extends CIFSException {

    /**
     * 
     */
    private static final long serialVersionUID = 7621650016319792189L;
    public static final String NO_NULL_REF = "ref pointer cannot be null";
    public static final String INVALID_CONFORMANCE = "invalid array conformance";


    public NdrException ( String msg ) {
        super(msg);
    }

 */

package jcifs.smb1.dcerpc.ndr;

import java.io.IOException;

public class NdrException extends IOException {

    public static final String NO_NULL_REF = "ref pointer cannot be null";
    public static final String INVALID_CONFORMANCE = "invalid array conformance";

    public NdrException( String msg ) {
        super( msg );
    }