org.bytedeco.pytorch

Class ConstantStringPtr

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.pytorch.ConstantStringPtr

All Implemented Interfaces:

AutoCloseable

@Name(value="c10::intrusive_ptr<c10::ivalue::ConstantString>")
 @NoOffset
 @Properties(inherit=torch.class)
public class ConstantStringPtr
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
ConstantStringPtr()
ConstantStringPtr(ConstantString target, DontIncreaseRefcount arg1)
ConstantStringPtr(ConstantStringPtr rhs)
ConstantStringPtr(long size) Native array allocator.
ConstantStringPtr(Pointer p) Pointer cast constructor.
ConstantStringPtr(PointerPointer arg0)

Method Summary

Modifier and Type	Method and Description
ConstantString	access()
boolean	asBoolean()
boolean	defined()
ConstantString	get()
ConstantStringPtr	getPointer(long i)
ConstantString	multiply()
ConstantStringPtr	position(long position)
ConstantStringPtr	put(ConstantStringPtr rhs)
static ConstantStringPtr	reclaim_copy(ConstantString owning_ptr) Takes an owning pointer to TTarget* and creates an intrusive_ptr representing a new reference, i.e.
static ConstantStringPtr	reclaim(ConstantString owning_ptr) Takes an owning pointer to TTarget* and creates an intrusive_ptr that takes over ownership.
ConstantString	release() Returns an owning (!) pointer to the underlying object and makes the intrusive_ptr instance invalid.
void	reset()
void	swap(ConstantStringPtr rhs)
boolean	unique()
static ConstantStringPtr	unsafe_adapt_non_heap_allocated(ConstantString 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 ConstantStringPtr	unsafe_reclaim_from_nonowning(ConstantString raw_ptr) Turn a **non-owning raw pointer** to an intrusive_ptr.
static ConstantStringPtr	unsafe_steal_from_new(ConstantString 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

ConstantStringPtr

public ConstantStringPtr(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

ConstantStringPtr

public ConstantStringPtr(long size)

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

ConstantStringPtr

public ConstantStringPtr()

ConstantStringPtr

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

ConstantStringPtr

public ConstantStringPtr(ConstantString target,
                         @ByVal
                         DontIncreaseRefcount arg1)

ConstantStringPtr

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

Method Detail

position

public ConstantStringPtr position(long position)

Overrides:

position in class Pointer

getPointer

public ConstantStringPtr getPointer(long i)

Overrides:

getPointer in class Pointer

put

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

get

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

multiply

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

access

@Name(value="operator ->")
 @NoException(value=true)
public ConstantString 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
                                          ConstantStringPtr 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 ConstantString 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 ConstantStringPtr reclaim(ConstantString 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 ConstantStringPtr reclaim_copy(ConstantString 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 ConstantStringPtr unsafe_steal_from_new(ConstantString 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 ConstantStringPtr unsafe_adapt_non_heap_allocated(ConstantString 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 ConstantStringPtr unsafe_reclaim_from_nonowning(ConstantString 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