org.bytedeco.pytorch

Class RRefInterfacePtr

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.pytorch.RRefInterfacePtr

All Implemented Interfaces:

AutoCloseable

@Name(value="c10::intrusive_ptr<c10::RRefInterface>")
 @NoOffset
 @Properties(inherit=torch.class)
public class RRefInterfacePtr
extends Pointer

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
RRefInterfacePtr()
RRefInterfacePtr(long size) Native array allocator.
RRefInterfacePtr(Pointer p) Pointer cast constructor.
RRefInterfacePtr(PointerPointer arg0)
RRefInterfacePtr(RRefInterface target, DontIncreaseRefcount arg1)
RRefInterfacePtr(RRefInterfacePtr rhs)

Method Summary

Modifier and Type	Method and Description
RRefInterface	access()
boolean	asBoolean()
boolean	defined()
RRefInterface	get()
RRefInterfacePtr	getPointer(long i)
RRefInterface	multiply()
RRefInterfacePtr	position(long position)
RRefInterfacePtr	put(RRefInterfacePtr rhs)
static RRefInterfacePtr	reclaim_copy(RRefInterface owning_ptr) Takes an owning pointer to TTarget* and creates an intrusive_ptr representing a new reference, i.e.
static RRefInterfacePtr	reclaim(RRefInterface owning_ptr) Takes an owning pointer to TTarget* and creates an intrusive_ptr that takes over ownership.
RRefInterface	release() Returns an owning (!) pointer to the underlying object and makes the intrusive_ptr instance invalid.
void	reset()
void	swap(RRefInterfacePtr rhs)
boolean	unique()
static RRefInterfacePtr	unsafe_adapt_non_heap_allocated(RRefInterface raw_ptr, long expected_decrefs) Turn an instance of TTarget that should not be reference counted (e.g., allocated into an arena with placement new) into an intrusive_ptr.
static RRefInterfacePtr	unsafe_reclaim_from_nonowning(RRefInterface raw_ptr) Turn a **non-owning raw pointer** to an intrusive_ptr.
static RRefInterfacePtr	unsafe_steal_from_new(RRefInterface raw_ptr) Turn a new instance of TTarget (e.g., literally allocated using new TTarget(...) into an intrusive_ptr.
long	use_count()
long	weak_use_count()

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, getDirectBufferAddress, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, physicalBytesInaccurate, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, sizeof, toString, totalBytes, totalCount, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

RRefInterfacePtr

public RRefInterfacePtr(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

RRefInterfacePtr

public RRefInterfacePtr(long size)

Native array allocator. Access with Pointer.position(long).

RRefInterfacePtr

public RRefInterfacePtr()

RRefInterfacePtr

public RRefInterfacePtr(@ByVal @Cast(value="std::nullptr_t*")
                        PointerPointer arg0)

RRefInterfacePtr

public RRefInterfacePtr(RRefInterface target,
                        @ByVal
                        DontIncreaseRefcount arg1)

RRefInterfacePtr

public RRefInterfacePtr(@ByRef(value=true)
                        RRefInterfacePtr rhs)

Method Detail

position

public RRefInterfacePtr position(long position)

Overrides:

position in class Pointer

getPointer

public RRefInterfacePtr getPointer(long i)

Overrides:

getPointer in class Pointer

put

@ByRef
 @Name(value="operator =")
 @NoException(value=true)
public RRefInterfacePtr put(@ByRef(value=true)
                                                                                        RRefInterfacePtr rhs)

get

@NoException(value=true)
public RRefInterface get()

multiply

@ByRef
 @Name(value="operator *")
 @NoException(value=true)
public RRefInterface multiply()

access

@Name(value="operator ->")
 @NoException(value=true)
public RRefInterface access()

asBoolean

@Cast(value="bool")
 @Name(value="operator bool")
 @NoException(value=true)
public boolean asBoolean()

reset

@NoException(value=true)
public void reset()

swap

@NoException(value=true)
public void swap(@ByRef
                                          RRefInterfacePtr rhs)

defined

@Cast(value="bool")
 @NoException(value=true)
public boolean defined()

use_count

@Cast(value="size_t")
 @NoException(value=true)
public long use_count()

weak_use_count

@Cast(value="size_t")
 @NoException(value=true)
public long weak_use_count()

unique

@Cast(value="bool")
 @NoException(value=true)
public boolean unique()

release

@NoException(value=true)
public RRefInterface release()

Returns an owning (!) pointer to the underlying object and makes the intrusive_ptr instance invalid. That means the refcount is not decreased. You *must* put the returned pointer back into a intrusive_ptr using intrusive_ptr::reclaim(ptr) to properly destruct it. This is helpful for C APIs.

reclaim

@ByVal
public static RRefInterfacePtr reclaim(RRefInterface owning_ptr)

Takes an owning pointer to TTarget* and creates an intrusive_ptr that takes over ownership. That means the refcount is not increased. This is the counter-part to intrusive_ptr::release() and the pointer passed in *must* have been created using intrusive_ptr::release().

reclaim_copy

@ByVal
public static RRefInterfacePtr reclaim_copy(RRefInterface owning_ptr)

Takes an owning pointer to TTarget* and creates an intrusive_ptr representing a new reference, i.e. the raw pointer retains ownership.

unsafe_steal_from_new

@ByVal
public static RRefInterfacePtr unsafe_steal_from_new(RRefInterface raw_ptr)

Turn a new instance of TTarget (e.g., literally allocated using new TTarget(...) into an intrusive_ptr. If possible, use intrusive_ptr::make instead which statically guarantees that the allocation was done properly. At the moment, the only reason this method exists is because pybind11 holder types expect to be able to allocate in this way (because pybind11 handles the new allocation itself).

unsafe_adapt_non_heap_allocated

@ByVal
public static RRefInterfacePtr unsafe_adapt_non_heap_allocated(RRefInterface raw_ptr,
                                                                      @Cast(value="size_t")
                                                                      long expected_decrefs)

Turn an instance of TTarget that should not be reference counted (e.g., allocated into an arena with placement new) into an intrusive_ptr. This is gratuitously unsafe and should only be used if you can guarantee that the pointer will not escape and be refcounted as normal. expected_decrefs is a debugging parameter: it indicates the number of strong owners the intrusive_ptr_target in question is expected to get. In most use cases, this will likely be 1. The reason this method exists is for manually sharing StorageImpls across Tensors in the static runtime. It needs access to private intrusive_ptr members so that the refcounts can be initialized to custom values.

unsafe_reclaim_from_nonowning

@ByVal
public static RRefInterfacePtr unsafe_reclaim_from_nonowning(RRefInterface raw_ptr)

Turn a **non-owning raw pointer** to an intrusive_ptr. It is the moral equivalent of enable_shared_from_this on a shared pointer. This method is only valid for objects that are already live. If you are looking for the moral equivalent of unique_ptr(T*) constructor, see steal_from_new. TODO: https://github.com/pytorch/pytorch/issues/56482